docs: 同步日常维护指南并补齐遗漏的板卡配置

mixly/boards/default_src/micropython/generators/actuator.js

@@ -0,0 +1,214 @@
+export const esp32_music_pitch = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var number_pitch = generator.valueToCode(this, 'pitch', generator.ORDER_ATOMIC);
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'music.pitch(' + pin + ', ' + number_pitch + ')\n';
+    return code;
+}
+
+export const esp32_music_pitch_with_time = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var number_pitch = generator.valueToCode(this, 'pitch', generator.ORDER_ATOMIC);
+    var number_time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'music.pitch_time(' + pin + ', ' + number_pitch + ', ' + number_time + ')\n';
+    return code;
+}
+
+export const esp32_music_stop = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'music.stop(' + pin + ')\n';
+    return code;
+}
+
+export const esp32_music_set_tempo = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var bpm = generator.valueToCode(this, 'BPM', generator.ORDER_ASSIGNMENT);
+    var ticks = generator.valueToCode(this, 'TICKS', generator.ORDER_ASSIGNMENT);
+    var code = "music.set_tempo(" + ticks + ", " + bpm + ")\n";
+    return code;
+}
+
+export const esp32_music_get_tempo = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var code = "music.get_tempo()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const esp32_onboard_music_pitch = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var number_pitch = generator.valueToCode(this, 'pitch', generator.ORDER_ATOMIC);
+    var code = 'music.pitch(' + number_pitch + ')\n';
+    return code;
+}
+
+export const esp32_onboard_music_pitch_with_time = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var number_pitch = generator.valueToCode(this, 'pitch', generator.ORDER_ATOMIC);
+    var number_time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var code = 'music.pitch_time(' + number_pitch + ', ' + number_time + ')\n';
+    return code;
+}
+
+export const esp32_onboard_music_stop = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var code = 'music.stop(' + ')\n';
+    return code;
+}
+
+export const esp32_onboard_music_play_list = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var lst = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT);
+    var code = "music.play(" + lst + ")\n";
+    return code;
+}
+
+export const esp32_music_play_list = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var lst = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT);
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ASSIGNMENT);
+    var code = "music.play(" + lst + ", " + pin + ")\n";
+    return code;
+}
+
+export const esp32_mixgo_music_play_list_show = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var lst = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT);
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ASSIGNMENT);
+    // var display = generator.valueToCode(this, 'DISPLAY', generator.ORDER_ASSIGNMENT);
+    var code = "music.play_show(" + lst + ", " + pin + ")\n";
+    return code;
+}
+
+export const esp32_music_reset = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    return "music.reset()\n";
+}
+
+export const servo_move = function (_, generator) {
+    generator.definitions_['import_servo'] = 'import servo';
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var value_degree = generator.valueToCode(this, 'DEGREE', generator.ORDER_ATOMIC);
+    var code = 'servo.servo_write_angle(' + dropdown_pin + ', ' + value_degree + ')\n';
+    return code;
+}
+
+export const number = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ledswitch = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_extern_led_bright = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    // var bright = this.getFieldValue('bright');
+    var code = "mixgo.led(" + pin + ").setonoff(" + bright + ")\n";
+    return code;
+}
+
+export const actuator_extern_get_led_bright = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = "mixgo.led(" + pin + ").getonoff(" + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_extern_led_brightness = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var flag = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = 'mixgo.led(' + pin + ').setbrightness(' + flag + ')\n';
+    return code;
+}
+
+export const actuator_led_bright = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    // var bright = this.getFieldValue('bright');
+    var code = "mixgo.led" + op + ".setonoff(" + bright + ")\n";
+    return code;
+}
+
+export const actuator_get_led_bright = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var code = "mixgo.led" + op + ".getonoff(" + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_led_brightness = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var flag = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = 'mixgo.led' + op + '.setbrightness(' + flag + ')\n';
+    return code;
+}
+
+export const actuator_neopixel_init = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var dropdown_rgbpin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var value_ledcount = generator.valueToCode(this, 'LEDCOUNT', generator.ORDER_ATOMIC);
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_neopixel'] = 'import neopixel';
+    var code = v + ' = neopixel.NeoPixel(machine.Pin(' + dropdown_rgbpin + '), ' + value_ledcount + ', timing=True)\n';
+    return code;
+}
+
+export const actuator_neopixel_write = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_neopixel'] = 'import neopixel';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.write()\n';
+    return code;
+}
+
+export const actuator_neopixel_rgb = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_neopixel'] = 'import neopixel';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var value_led = generator.valueToCode(this, '_LED_', generator.ORDER_ATOMIC);
+    var value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    var value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    var value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    var code = v + '[' + value_led + '] = (' + value_rvalue + ', ' + value_gvalue + ', ' + value_bvalue + ')\n';
+    return code;
+}
+
+export const actuator_onboard_neopixel_write = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var code = 'mixgo.rgb.write()\n';
+    return code;
+}
+
+export const actuator_onboard_neopixel_rgb = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var value_led = generator.valueToCode(this, '_LED_', generator.ORDER_ATOMIC);
+    var value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    var value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    var value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    var code = 'mixgo.rgb[' + value_led + '] = (' + value_rvalue + ', ' + value_gvalue + ', ' + value_bvalue + ')\n';
+    return code;
+}
+
+export const actuator_onboard_neopixel_rgb_all = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    var value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    var value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    var code = 'mixgo.rgb.fill((' + value_rvalue + ', ' + value_gvalue + ', ' + value_bvalue + '))\n';
+    return code;
+}
+
+export const led_light = actuator_led_bright;
+export const get_led_bright = actuator_get_led_bright;
+export const led_brightness = actuator_led_brightness;

mixly/boards/default_src/micropython/generators/actuator_extern.js

@@ -0,0 +1,713 @@
+import { Boards } from 'mixly';
+
+export const servo_init = function (_, generator) {
+    generator.definitions_['import_servo'] = 'import servo';
+    generator.definitions_['import_board'] = 'import board';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = v + ' = servo.Servo(board.' + dropdown_pin + ')\n';
+    return code;
+}
+
+export const servo_speed_360 = function (_, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var speed = generator.valueToCode(this, 'SPEED', generator.ORDER_ATOMIC);
+    var code = v + '.set_speed(' + speed + ')\n';
+    return code;
+}
+
+export const servo_set_angle = function (_, generator) {
+    generator.definitions_['import_servo'] = 'import servo';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    var code = 'servo.servo180_angle(' + dropdown_pin + ', ' + num + ')\n';
+    return code;
+}
+
+export const servo_set_speed = function (_, generator) {
+    generator.definitions_['import_servo'] = 'import servo';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    var code = 'servo.servo360_speed(' + dropdown_pin + ', ' + num + ')\n';
+    return code;
+}
+
+export const servo_get_angle = function (_, generator) {
+    generator.definitions_['import_servo'] = 'import servo';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'servo.servo180_angle(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const servo_get_speed = function (_, generator) {
+    generator.definitions_['import_servo'] = 'import servo';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'servo.servo360_speed(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+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;
+}
+
+export const esp32_music_pitch_init = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var dropdown_rgbpin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    generator.definitions_['import_music'] = 'import music';
+    var code = v + ' = music.MIDI(' + dropdown_rgbpin + ')\n';
+    return code;
+}
+
+export const esp32_music_pitch = function (block, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var number_pitch = generator.valueToCode(block, 'pitch', generator.ORDER_ATOMIC);
+    var code = v + '.pitch(' + number_pitch + ')\n';
+    return code;
+}
+
+export const esp32_music_pitch_with_time = function (block, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var number_pitch = generator.valueToCode(block, 'pitch', generator.ORDER_ATOMIC);
+    var number_time = generator.valueToCode(block, 'time', generator.ORDER_ATOMIC);
+    var code = v + '.pitch_time(' + number_pitch + ', ' + number_time + ')\n';
+    return code;
+}
+
+export const esp32_music_stop = function (block, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.stop(' + ')\n';
+    return code;
+}
+
+export const esp32_set_music_volume = function (_,generator){
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var p = generator.valueToCode(this, 'percent', generator.ORDER_ATOMIC);
+    var code = v+'.set_volume('+p+')\n';
+    return code;
+}
+
+export const esp32_music_set_tempo_extern = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bpm = generator.valueToCode(this, 'BPM', generator.ORDER_ASSIGNMENT);
+    var ticks = generator.valueToCode(this, 'TICKS', generator.ORDER_ASSIGNMENT);
+    var code = v + ".set_tempo(" + ticks + ", " + bpm + ")\n";
+    return code;
+}
+
+export const esp32_music_get_tempo_extern = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + ".get_tempo()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const esp32_music_play_list = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var lst = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT);
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + ".play(" + v + '.' + lst + ")\n";
+    return code;
+}
+
+export const backstage_esp32_music_play_list = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var lst = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT);
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + ".play_thread(" + v + '.' + lst + ")\n";
+    return code;
+}
+
+export const esp32_music_reset_extern = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    return v + ".reset()\n";
+}
+
+export const servo_move = function (_, generator) {
+    generator.definitions_['import_servo'] = 'import servo';
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var value_degree = generator.valueToCode(this, 'DEGREE', generator.ORDER_ATOMIC);
+    var code = 'servo.servo_write_angle(' + dropdown_pin + ', ' + value_degree + ')\n';
+    return code;
+}
+
+export const actuator_extern_led_bright = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    // var bright = this.getFieldValue('bright');
+    var code = "mixgo.LED(" + pin + ").setonoff(" + bright + ")\n";
+    return code;
+}
+
+export const actuator_extern_get_led_bright = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = "mixgo.LED(" + pin + ").getbrightness(" + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_extern_get_led_state = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = "mixgo.LED(" + pin + ").getonoff(" + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_extern_led_brightness = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var flag = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = 'mixgo.LED(' + pin + ').setbrightness(' + flag + ')\n';
+    return code;
+}
+
+export const actuator_neopixel_init = function (_, generator) {
+    const v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    const dropdown_rgbpin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    const value_ledcount = generator.valueToCode(this, 'LEDCOUNT', generator.ORDER_ATOMIC);
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ws2812_Neopixel'] = 'from ws2812 import NeoPixel';
+    const code = `${v} = NeoPixel(machine.Pin(${dropdown_rgbpin}), ${value_ledcount})\n`;
+    return code;
+}
+
+export const actuator_neopixel_rgb_all = function (_, generator) {
+    const v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    const value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    const value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    const value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    const code = `${v}.fill((${value_rvalue}, ${value_gvalue}, ${value_bvalue}))\n`;
+    return code;
+}
+
+export const actuator_neopixel_write = function (_, generator) {
+    const v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    const code = `${v}.write()\n`;
+    return code;
+}
+
+export const actuator_neopixel_rgb = function (_, generator) {
+    const v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    const value_led = generator.valueToCode(this, '_LED_', generator.ORDER_ATOMIC);
+    const value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    const value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    const value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    const code = `${v}[${value_led}] = (${value_rvalue}, ${value_gvalue}, ${value_bvalue})\n`;
+    return code;
+}
+
+export const actuator_neopixel_rgb_show_all_chase = function (_, generator) {
+    const v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    const value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    const value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    const value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    const number_time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    const code = `${v}.color_chase(${value_rvalue}, ${value_gvalue}, ${value_bvalue}, ${number_time})\n`;
+    return code;
+}
+
+export const actuator_neopixel_rgb_show_all_rainbow = function (_, generator) {
+    const v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    const number_time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    const code = `${v}.rainbow_cycle(${number_time})\n`;
+    return code;
+}
+
+export const actuator_use_uart_init = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var key2 = this.getFieldValue('key2');
+    if (key2 == 'SYN6288') {
+        generator.definitions_['import_syn6288'] = 'import syn6288';
+        var code = v + '=syn6288.SYN6288(' + key + ')\n';
+        return code;
+    } else if (key2 == 'NS9300') {
+        generator.definitions_['import_ns9300'] = 'import ns9300';
+        var code = v + '=ns9300.NS9300(' + key + ')\n';
+        return code;
+    }
+}
+
+export const player_whether_stop = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = v + '.status(' + key + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const player_set_play = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = v + '.control(' + key + ')\n';
+    return code;
+}
+
+export const player_set_volume = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var vol = generator.valueToCode(this, 'volume', generator.ORDER_ATOMIC);
+    var code = v + '.volume(' + vol + ')\n';
+    return code;
+}
+
+export const player_set_mode = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = v + '.mode(' + key + ')\n';
+    return code;
+}
+
+export const player_play_music = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var s = generator.valueToCode(this, 'song', generator.ORDER_ATOMIC);
+    var code = v + '.' + key + '(' + s + ')\n';
+    return code;
+}
+
+export const syn6288_set_voice = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var voice = generator.valueToCode(this, 'VOICE', generator.ORDER_ASSIGNMENT);
+    var code = v + ".volume(" + voice + ")\n";
+    return code;
+}
+
+export const syn6288_get_voice = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + ".volume()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const syn6288_builtin_voice = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var mode = this.getFieldValue('mode');
+    var voice = generator.valueToCode(this, 'VOICE', generator.ORDER_ASSIGNMENT);
+    var code = v + ".hint_tones(" + voice + ', blocking=' + mode + ")\n";
+    return code;
+}
+
+export const syn6288_tts_play = function (_, generator) {
+    generator.definitions_['import_music'] = 'import music';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var mode = this.getFieldValue('mode');
+    var voice = generator.valueToCode(this, 'VOICE', generator.ORDER_ASSIGNMENT);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".synthesis(" + data + ', music=' + voice + ', blocking=' + mode + ")\n";
+    return code;
+}
+
+//mixbot extern below:
+export const mixbot_addr_extern = function (_, generator) {
+    var code = this.getFieldValue('PIN');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const robot_motor_extern = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_motor'] = 'from mixbot_ext import ext_motor';
+        var code = 'ext_motor.run(' + mode + ',' + speed + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_motor'] = 'ext_motor_left = i2cdevice.Motor(ext_i2c_left)';
+            var code = 'ext_motor_left.run(0,' + speed + ')\n';
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_motor'] = 'ext_motor_right = i2cdevice.Motor(ext_i2c_right)';
+            var code = 'ext_motor_right.run(0,' + speed + ')\n';
+        }
+        return code;
+    }
+}
+
+export const robot_motor_extern_get_speed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    if (version == 'mixbot') {
+        var code = 'ext_motor.run(' + mode + ")";
+        return [code, generator.ORDER_ATOMIC];
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_motor'] = 'ext_motor_left = i2cdevice.Motor(ext_i2c_left)';
+            var code = 'ext_motor_left.run()';
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_motor'] = 'ext_motor_right = i2cdevice.Motor(ext_i2c_right)';
+            var code = 'ext_motor_right.run()';
+        }
+        return [code, generator.ORDER_ATOMIC];
+    }
+}
+
+export const robot_traffic_light_extern = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var light = this.getFieldValue('light');
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_traffic'] = 'from mixbot_ext import ext_traffic';
+        var mode = this.getFieldValue('mode');
+        var light = this.getFieldValue('light');
+        var code = 'ext_traffic.led(' + mode + ', ';
+        if (light == '0' || light == '1' || light == '2') { code += '0' + ', ' }
+        else if (light == '3' || light == '4') { code += '1' + ',' }
+        else if (light == '5' || light == '6') { code += '2' + ',' }
+        if (light == '0') { code += '0' }
+        else if (light == '1' || light == '3' || light == '5') { code += '1' }
+        else if (light == '2' || light == '4' || light == '6') { code += '-1' }
+        code += ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_traffic'] = 'ext_traffic_left = i2cdevice.Traffic_LED(ext_i2c_left)';
+            var code = 'ext_traffic_left.led(0,';
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_traffic'] = 'ext_traffic_right = i2cdevice.Traffic_LED(ext_i2c_right)';
+            var code = 'ext_traffic_right.led(0,';
+        }
+        if (light == '0' || light == '1' || light == '2') { code += '0' + ',' }
+        else if (light == '3' || light == '4') { code += '1' + ',' }
+        else if (light == '5' || light == '6') { code += '2' + ',' }
+        if (light == '0') { code += '0' }
+        else if (light == '1' || light == '3' || light == '5') { code += '1' }
+        else if (light == '2' || light == '4' || light == '6') { code += '-1' }
+        code += ")\n";
+        return code;
+    }
+}
+
+export const robot_led_extern = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var color = this.getFieldValue('color');
+    var value = generator.valueToCode(this, 'value', generator.ORDER_ATOMIC);
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_' + color + '_LED'] = 'from mixbot_ext import ' + color + '_LED';
+        var code = color + '_LED.brightness(' + mode + ', ' + value + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_' + color + '_LED'] = 'ext_' + color + '_LED_left = i2cdevice.' + color + '_LED(ext_i2c_left)';
+            var code = 'ext_' + color + '_LED_left.brightness(' + '0, ' + value + ")\n";
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_' + color + '_LED'] = 'ext_' + color + '_LED_right = i2cdevice.' + color + '_LED(ext_i2c_right)';
+            var code = 'ext_' + color + '_LED_right.brightness(' + '0, ' + value + ")\n";
+        }
+        return code;
+    }
+}
+
+export const robot_led_extern_get_value = function (_, generator) {
+    var mode = this.getFieldValue('mode');
+    var color = this.getFieldValue('color');
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_' + color + '_LED'] = 'from mixbot_ext import ' + color + '_LED';
+        var code = color + '_LED.brightness(' + mode + ")";
+        return [code, generator.ORDER_ATOMIC];
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_' + color + '_LED'] = 'ext_' + color + '_LED_left = i2cdevice.' + color + '_LED(ext_i2c_left)';
+            var code = 'ext_' + color + '_LED_left.brightness(0)';
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_' + color + '_LED'] = 'ext_' + color + '_LED_right = i2cdevice.' + color + '_LED(ext_i2c_right)';
+            var code = 'ext_' + color + '_LED_right.brightness(0)';
+        }
+        return [code, generator.ORDER_ATOMIC];
+    }
+}
+
+export const robot_servo_extern_get_status = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var status = this.getFieldValue('status');
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_servo'] = 'from mixbot_ext import ext_servo';
+        var code = 'ext_servo.state(' + mode + ")" + status;
+        return [code, generator.ORDER_ATOMIC];
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_servo'] = 'ext_servo_left = i2cdevice.Motor_servo(ext_i2c_left)';
+            var code = 'ext_servo_left.state(0)' + status;
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_servo'] = 'ext_servo_right = i2cdevice.Motor_servo(ext_i2c_right)';
+            var code = 'ext_servo_right.state(0)' + status;
+        }
+        return [code, generator.ORDER_ATOMIC];
+    }
+}
+
+export const robot_servo_extern_stop_mode = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var status = this.getFieldValue('status');
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_servo'] = 'from mixbot_ext import ext_servo';
+        var code = 'ext_servo.stop_mode(' + mode + ", " + status + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left=i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_servo'] = 'ext_servo_left = i2cdevice.Motor_servo(ext_i2c_left)';
+            var code = 'ext_servo_left.stop_mode(' + "0, " + status + ")\n";
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_servo'] = 'ext_servo_right = i2cdevice.Motor_servo(ext_i2c_right)';
+            var code = 'ext_servo_right.stop_mode(' + "0, " + status + ")\n";
+        }
+        return code;
+    }
+}
+
+export const robot_servo_extern_stop = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_servo'] = 'from mixbot_ext import ext_servo';
+        var code = 'ext_servo.stop(' + mode + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_servo'] = 'ext_servo_left = i2cdevice.Motor_servo(ext_i2c_left)';
+            var code = 'ext_servo_left.stop(0)\n';
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_servo'] = 'ext_servo_right = i2cdevice.Motor_servo(ext_i2c_right)';
+            var code = 'ext_servo_right.stop(0)\n';
+        }
+        return code;
+    }
+}
+
+export const robot_servo_extern_absolute_run = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var status = this.getFieldValue('status');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var direction = this.getFieldValue('direction');
+    var angle = generator.valueToCode(this, 'angle', generator.ORDER_ATOMIC);
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_servo'] = 'from mixbot_ext import ext_servo';
+        var code = 'ext_servo.absolute_run(' + mode + ", " + status + ", " + speed + ", " + direction + ", " + angle + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_servo'] = 'ext_servo_left = i2cdevice.Motor_servo(ext_i2c_left)';
+            var code = 'ext_servo_left.absolute_run(' + "0, " + status + ", " + speed + ", " + direction + ", " + angle + ")\n";
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_servo'] = 'ext_servo_right = i2cdevice.Motor_servo(ext_i2c_right)';
+            var code = 'ext_servo_right.absolute_run(' + "0, " + status + ", " + speed + ", " + direction + ", " + angle + ")\n";
+        }
+        return code;
+    }
+}
+
+export const robot_servo_extern_relative_origin = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_servo'] = 'from mixbot_ext import ext_servo';
+        var code = 'ext_servo.relative_origin(' + mode + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_servo'] = 'ext_servo_left = i2cdevice.Motor_servo(ext_i2c_left)';
+            var code = 'ext_servo_left.relative_origin(0)\n';
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_servo'] = 'ext_servo_right = i2cdevice.Motor_servo(ext_i2c_right)';
+            var code = 'ext_servo_right.relative_origin(0)\n';
+        }
+        return code;
+    }
+}
+
+export const robot_servo_extern_relative_run = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var status = this.getFieldValue('status');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var angle = generator.valueToCode(this, 'angle', generator.ORDER_ATOMIC);
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_servo'] = 'from mixbot_ext import ext_servo';
+        var code = 'ext_servo.relative_run(' + mode + ", " + status + ", " + speed + ", " + angle + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_servo'] = 'ext_servo_left = i2cdevice.Motor_servo(ext_i2c_left)';
+            var code = 'ext_servo_left.relative_run(' + "0, " + status + ", " + speed + ", " + angle + ")\n";
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_servo'] = 'ext_servo_right = i2cdevice.Motor_servo(ext_i2c_right)';
+            var code = 'ext_servo_right.relative_run(' + "0, " + status + ", " + speed + ", " + angle + ")\n";
+        }
+        return code;
+    }
+}
+
+export const robot_servo_extern_relative_continue = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var mode = this.getFieldValue('mode');
+    var status = this.getFieldValue('status');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var direction = this.getFieldValue('direction');
+    if (version == 'mixbot') {
+        generator.definitions_['import_mixbot_ext_ext_servo'] = 'from mixbot_ext import ext_servo';
+        var code = 'ext_servo.relative_continue(' + mode + ", " + status + ", " + speed + ", " + direction + ")\n";
+        return code;
+    } else if (version == 'feiyi') {
+        generator.definitions_['import_machine'] = 'import machine';
+        generator.definitions_['import_i2cdevice'] = 'import i2cdevice';
+        if (mode == "0") {
+            generator.definitions_['import_left_ext_i2c'] = 'ext_i2c_left = i2cdevice.I2C_device(scl=machine.Pin(0), sda=machine.Pin(1), freq=10000)';
+            generator.definitions_['import_left_servo'] = 'ext_servo_left = i2cdevice.Motor_servo(ext_i2c_left)';
+            var code = 'ext_servo_left.relative_continue(' + "0, " + status + ", " + speed + ", " + direction + ")\n";
+        } else if (mode == "1") {
+            generator.definitions_['import_right_ext_i2c'] = 'ext_i2c_right = i2cdevice.I2C_device(scl=machine.Pin(2), sda=machine.Pin(3), freq=10000)';
+            generator.definitions_['import_right_servo'] = 'ext_servo_right = i2cdevice.Motor_servo(ext_i2c_right)';
+            var code = 'ext_servo_right.relative_continue(' + "0, " + status + ", " + speed + ", " + direction + ")\n";
+        }
+        return code;
+    }
+}
+
+export const mixbot_actuator_extern_get_addr = function (_, generator) {
+    var name = this.getFieldValue('name');
+    generator.definitions_['import_mixbot_ext_' + name] = 'from mixbot_ext import ' + name;
+    var code = name + '.addr_get()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const mixbot_actuator_extern_set_addr = function (_, generator) {
+    var name = this.getFieldValue('name');
+    generator.definitions_['import_mixbot_ext_' + name] = 'from mixbot_ext import ' + name;
+    var oldaddr = generator.valueToCode(this, 'old', generator.ORDER_ATOMIC);
+    var newaddr = generator.valueToCode(this, 'new', generator.ORDER_ATOMIC);
+    var code = name + '.addr_set(' + oldaddr + ', ' + newaddr + ')\n';
+    return code;
+}
+
+//educore
+export const PIN_init = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'pin'] = 'from ' + version + ' import pin';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'pin(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const pin_led_bright = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var pin = generator.valueToCode(this, 'pin', generator.ORDER_ATOMIC);
+    generator.definitions_['import_' + version + 'pin'] = 'from ' + version + ' import pin';
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = pin + ".write_digital(value=" + bright + ")\n";
+    return code;
+}
+
+export const servo_PIN_init = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'servo'] = 'from ' + version + ' import servo';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'servo(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const servo_move_angle = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'servo'] = 'from ' + version + ' import servo';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var a = generator.valueToCode(this, 'angle', generator.ORDER_ATOMIC);
+    var code = sub + '.angle(' + a + ')\n';
+    return code;
+}
+
+export const parrot_PIN_init = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'parrot'] = 'from ' + version + ' import parrot';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'parrot(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const parrot_move_speed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'parrot'] = 'from ' + version + ' import parrot';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = sub + '.speed(' + speed + ')\n';
+    return code;
+}

mixly/boards/default_src/micropython/generators/actuator_onboard.js

@@ -0,0 +1,837 @@
+import { Boards } from 'mixly';
+
+export const esp32_music_set_tempo = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+    var bpm = generator.valueToCode(this, 'BPM', generator.ORDER_ASSIGNMENT);
+    var ticks = generator.valueToCode(this, 'TICKS', generator.ORDER_ASSIGNMENT);
+    var code = "onboard_music.set_tempo(" + ticks + ", " + bpm + ")\n";
+    return code;
+}
+
+export const esp32_music_get_tempo = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+    var code = "onboard_music.get_tempo()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const esp32_onboard_music_pitch = function (block, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+    var number_pitch = generator.valueToCode(block, 'pitch', generator.ORDER_ATOMIC);
+    var code = 'onboard_music.pitch(' + number_pitch + ')\n';
+    return code;
+}
+
+export const esp32_onboard_music_pitch_with_time = function (block, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var number_pitch = generator.valueToCode(block, 'pitch', generator.ORDER_ATOMIC);
+    var number_time = generator.valueToCode(block, 'time', generator.ORDER_ATOMIC);
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_spk_midi'] = "from mixgo_zero_voice import spk_midi";
+        var code = 'spk_midi.pitch_time(' + number_pitch + ', ' + number_time + ')\n';
+    } else if (version == 'mixgo_nova') {
+        generator.definitions_['import_mixgo_nova_voice_spk_midi'] = "from mixgo_nova_voice import spk_midi";
+        var code = 'spk_midi.pitch_time(' + number_pitch + ', ' + number_time + ')\n';
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_spk_midi'] = "from mixgo_soar_voice import spk_midi";
+        var code = 'spk_midi.pitch_time(' + number_pitch + ', ' + number_time + ')\n';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+        var code = 'onboard_music.pitch_time(' + number_pitch + ', ' + number_time + ')\n';
+    }
+    return code;
+}
+
+export const esp32_onboard_music_stop = function (block, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+    var code = 'onboard_music.stop(' + ')\n';
+    return code;
+}
+
+export const esp32_onboard_music_play_list = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var lst = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT);
+    if (version == 'mixgo_sant') {
+        generator.definitions_['import_mixgo_sant_onboard_music'] = "from mixgo_sant import onboard_music";
+        var code = "onboard_music.play(" + lst + ")\n";
+    } else if (version == 'mixgo_nova') {
+        generator.definitions_['import_mixgo_nova_voice_spk_midi'] = "from mixgo_nova_voice import spk_midi";
+        var code = "spk_midi.play(" + lst + ")\n";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_spk_midi'] = "from mixgo_soar_voice import spk_midi";
+        var code = "spk_midi.play(" + lst + ")\n";
+    } else {
+        generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+        var code = "onboard_music.play(" + lst + ")\n";
+    }
+    return code;
+}
+
+export const backstage_onboard_music_play_list = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var lst = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT);
+    generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+    var code = "onboard_music.play_thread(" + lst + ")\n";
+    return code;
+}
+
+export const esp32_music_reset = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+    return "onboard_music.reset()\n";
+}
+
+export const number = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ledswitch = function (_, generator) {
+    var code = this.getFieldValue('flag');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_led_bright = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    if (version == 'mixgo'){
+        if(op == 1){
+            generator.definitions_['import_' + version + 'led1'] = 'from ' + version + ' import led1';
+            var code = "led1.setonoff(" + bright + ")\n";
+        }else if (op == 2){
+            generator.definitions_['import_' + version + 'led2'] = 'from ' + version + ' import led2';
+            var code = "led2.setonoff("+ bright + ")\n";
+        }
+    }else{
+        generator.definitions_['import_' + version + '_onboard_led'] = 'from ' + version + ' import onboard_led';
+        var code = "onboard_led.setonoff(" + op + "," + bright + ")\n";
+    }
+    return code;
+}
+
+export const actuator_get_led_bright = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    if (version == 'mixgo'){
+        if(op == 1){
+            generator.definitions_['import_' + version + 'led1'] = 'from ' + version + ' import led1';
+            var code = "led1.getbrightness()";
+        }else if (op == 2){
+            generator.definitions_['import_' + version + 'led2'] = 'from ' + version + ' import led2';
+            var code = "led2.getbrightness()";
+        }
+    }else{
+        generator.definitions_['import_' + version + '_onboard_led'] = 'from ' + version + ' import onboard_led';
+        var code = "onboard_led.getbrightness(" + op + ")";
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_get_led_state = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    if (version == 'mixgo'){
+        if(op == 1){
+            generator.definitions_['import_' + version + 'led1'] = 'from ' + version + ' import led1';
+            var code = "led1.getonoff()";
+        }else if (op == 2){
+            generator.definitions_['import_' + version + 'led2'] = 'from ' + version + ' import led2';
+            var code = "led2.getonoff()";
+        }
+    }else{
+        generator.definitions_['import_' + version + '_onboard_led'] = 'from ' + version + ' import onboard_led';
+        var code = "onboard_led.getonoff(" + op + ")";
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_led_brightness = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var flag = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    if (version == 'mixgo'){
+        if(op == 1){
+            generator.definitions_['import_' + version + 'led1'] = 'from ' + version + ' import led1';
+            var code = "led1.setbrightness("+ flag + ")\n";
+        }else if (op == 2){
+            generator.definitions_['import_' + version + 'led2'] = 'from ' + version + ' import led2';
+            var code = "led2.setbrightness("+ flag + ")\n";
+        }
+    }else{
+        generator.definitions_['import_' + version + '_onboard_led'] = 'from ' + version + ' import onboard_led';
+        var code = "onboard_led.setbrightness(" + op + ", " + flag + ")\n";
+    }
+    return code;
+}
+
+export const actuator_mixgo_zero_led_color = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    generator.definitions_['import_' + version + '_onboard_led'] = 'from ' + version + ' import onboard_led';
+    var color = this.getFieldValue('colorvalue');
+    var code = "onboard_led.setcolor(" + op + ", " + color + ")\n";
+    return code;
+}
+
+export const cc_number = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const rm_actuator_led_bright = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = this.getFieldValue('color');
+    generator.definitions_['import_' + version + '_' + op + 'led'] = 'from ' + version + ' import ' + op + 'led';
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = op + "led.setonoff(" + bright + ")\n";
+    return code;
+}
+
+export const rm_actuator_get_led_bright = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = this.getFieldValue('color');
+    generator.definitions_['import_' + version + '_' + op + 'led'] = 'from ' + version + ' import ' + op + 'led';
+    var code = op + "led.getbrightness()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const rm_actuator_get_led_state = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = this.getFieldValue('color');
+    generator.definitions_['import_' + version + '_' + op + 'led'] = 'from ' + version + ' import ' + op + 'led';
+    var code = op + "led.getonoff()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const rm_actuator_led_brightness = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var op = this.getFieldValue('color');
+    generator.definitions_['import_' + version + '_' + op + 'led'] = 'from ' + version + ' import ' + op + 'led';
+    var flag = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = op + "led.setbrightness(" + flag + ")\n";
+    return code;
+}
+
+export const actuator_onboard_neopixel_write = function (_, generator) {
+    const version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_[`import_${version}_onboard_rgb`] = `from ${version} import onboard_rgb`;
+    const code = 'onboard_rgb.write()\n';
+    return code;
+}
+
+export const actuator_onboard_neopixel_rgb = function (_, generator) {
+    const version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_[`import_${version}_onboard_rgb`] = `from ${version} import onboard_rgb`;
+    const value_led = generator.valueToCode(this, '_LED_', generator.ORDER_ATOMIC);
+    const value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    const value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    const value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    const code = `onboard_rgb[${value_led}] = (${value_rvalue}, ${value_gvalue}, ${value_bvalue})\n`;
+    return code;
+}
+
+export const actuator_onboard_neopixel_rgb_all = function (_, generator) {
+    const version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_[`import_${version}_onboard_rgb`] = `from ${version} import onboard_rgb`;
+    const value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    const value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    const value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    const code = `onboard_rgb.fill((${value_rvalue}, ${value_gvalue}, ${value_bvalue}))\n`;
+    return code;
+}
+
+export const actuator_onboard_neopixel_rgb_show_all_chase = function (_, generator) {
+    const version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_[`import_${version}_onboard_rgb`] = `from ${version} import onboard_rgb`;
+    const value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    const value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    const value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    const number_time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    const code = `onboard_rgb.color_chase(${value_rvalue}, ${value_gvalue}, ${value_bvalue}, ${number_time})\n`;
+    return code;
+}
+
+export const actuator_onboard_neopixel_rgb_show_all_rainbow = function (_, generator) {
+    const version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_[`import_${version}_onboard_rgb`] = `from ${version} import onboard_rgb`;
+    const number_time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    const code = `onboard_rgb.rainbow_cycle(${number_time})\n`;
+    return code;
+}
+
+export const rm_motor = function (_, generator) {
+    var wheel = this.getFieldValue('wheel');
+    generator.definitions_['import_rm_e1_motor' + wheel] = 'from rm_e1 import motor' + wheel;
+    var v = this.getFieldValue('direction');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = "motor" + wheel + '.motion("' + v + '",' + speed + ")\n";
+    return code;
+}
+
+//c3 motor onboard
+export const actuator_stepper_keep = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    generator.definitions_['import_mixgocar_c3_car'] = 'from mixgocar_c3 import car';
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ASSIGNMENT);
+    var code = 'car.motor_move("' + v + '",' + speed + ")\n";
+    return code;
+}
+
+export const actuator_stepper_stop = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    generator.definitions_['import_mixgocar_c3_car'] = 'from mixgocar_c3 import car';
+    var code = 'car.motor_move("' + v + '"' + ")\n";
+    return code;
+}
+
+export const actuator_dc_motor = function (_, generator) {
+    var wheel = this.getFieldValue('wheel');
+    generator.definitions_['import_mixgocar_c3_car'] = 'from mixgocar_c3 import car';
+    var v = this.getFieldValue('direction');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = "car.motor(car.MOTO_" + wheel + ', "' + v + '", ' + speed + ")\n";
+    return code;
+}
+
+export const actuator_dc_motor_stop = function (_, generator) {
+    var wheel = this.getFieldValue('wheel');
+    generator.definitions_['import_mixgocar_c3_car'] = 'from mixgocar_c3 import car';
+    var v = this.getFieldValue('direction');
+    var code = "car.motor(car.MOTO_" + wheel + ', "' + v + '"' + ")\n";
+    return code;
+}
+
+//mixbot onboard_motor below:
+
+export const mixbot_motor_status = function (_, generator) {
+    generator.definitions_['import_mixbot_motor'] = 'from mixbot import motor';
+    var code = 'motor.status()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const mixbot_move = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    var mode = this.getFieldValue('mode');
+    generator.definitions_['import_mixbot_motor'] = 'from mixbot import motor';
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ASSIGNMENT);
+    var code = 'motor.move("' + v + '", motor.' + mode + '_MODE,' + speed + ")\n";
+    return code;
+}
+
+export const mixbot_stop = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    generator.definitions_['import_mixbot_motor'] = 'from mixbot import motor';
+    if (v == 'N') {
+        var code = 'motor.move("N", motor.STOP_MODE)\n'
+    } else if (v == 'P') {
+        var code = 'motor.move("P", motor.BRAKE_MODE)\n'
+    }
+    return code;
+}
+
+export const mixbot_motor = function (_, generator) {
+    var wheel = this.getFieldValue('wheel');
+    generator.definitions_['import_mixbot_motor'] = 'from mixbot import motor';
+    var mode = this.getFieldValue('mode');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = 'motor.run(' + wheel + ', motor.' + mode + '_MODE, ' + speed + ")\n";
+    return code;
+}
+
+export const actuator_mixbot_buzzer_on_off = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_spk_en'] = 'from ' + version + ' import spk_en';
+    var op = this.getFieldValue('on_off');
+    var code = "spk_en.value(" + op + ")\n";
+    return code;
+}
+
+//bitbot onboard_motor below:
+export const bitbot_move = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    generator.definitions_['import_feiyi_onboard_bot51'] = 'from feiyi import onboard_bot51';
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ASSIGNMENT);
+    var code = 'onboard_bot51.move("' + v + '", ' + speed + ")\n";
+    return code;
+}
+
+export const bitbot_stop = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    generator.definitions_['import_feiyi_onboard_bot51'] = 'from feiyi import onboard_bot51';
+    var code = 'onboard_bot51.move("' + v + '"' + ")\n";
+    return code;
+}
+
+export const bitbot_motor = function (_, generator) {
+    var wheel = this.getFieldValue('wheel');
+    var direction = this.getFieldValue('direction');
+    generator.definitions_['import_feiyi_onboard_bot51'] = 'from feiyi import onboard_bot51';
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = 'onboard_bot51.motor(' + wheel + ', "' + direction + '", ' + speed + ")\n";
+    return code;
+}
+
+export const actuator_mixgo_nova_mic_set = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_ob_code'] = "from mixgo_zero_voice import ob_code";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_ob_code'] = "from mixgo_soar_voice import ob_code";
+    } else {
+        generator.definitions_['import_mixgo_nova_voice_ob_code'] = "from mixgo_nova_voice import ob_code";
+    }
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = "ob_code.mic_volume(" + bright + ")\n";
+    return code;
+}
+
+export const actuator_mixgo_nova_mic_get = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_ob_code'] = "from mixgo_zero_voice import ob_code";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_ob_code'] = "from mixgo_soar_voice import ob_code";
+    } else {
+        generator.definitions_['import_mixgo_nova_voice_ob_code'] = "from mixgo_nova_voice import ob_code";
+    }
+    var code = "ob_code.mic_volume()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_mixgo_nova_voice_set = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_ob_code'] = "from mixgo_zero_voice import ob_code";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_ob_code'] = "from mixgo_soar_voice import ob_code";
+    } else {
+        generator.definitions_['import_mixgo_nova_voice_ob_code'] = "from mixgo_nova_voice import ob_code";
+    }
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = "ob_code.voice_volume(" + bright + ")\n";
+    return code;
+}
+
+export const actuator_mixgo_nova_voice_get = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_ob_code'] = "from mixgo_zero_voice import ob_code";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_ob_code'] = "from mixgo_soar_voice import ob_code";
+    } else {
+        generator.definitions_['import_mixgo_nova_voice_ob_code'] = "from mixgo_nova_voice import ob_code";
+    }
+    var code = "ob_code.voice_volume()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const actuator_mixgo_nova_record_audio = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_record_audio'] = "from mixgo_zero_voice import record_audio";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_record_audio'] = "from mixgo_soar_voice import record_audio";
+    } else {
+        generator.definitions_['import_mixgo_nova_voice_record_audio'] = "from mixgo_nova_voice import record_audio";
+    }
+    var path = generator.valueToCode(this, 'PATH', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'TIME', generator.ORDER_ASSIGNMENT);
+    var code = "record_audio(" + path + ", " + time + ")\n";
+    return code;
+}
+
+export const actuator_mixgo_nova_play_audio = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_play_audio'] = "from mixgo_zero_voice import play_audio";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_play_audio'] = "from mixgo_soar_voice import play_audio";
+    } else {
+        generator.definitions_['import_mixgo_nova_voice_play_audio'] = "from mixgo_nova_voice import play_audio";
+    }
+    var path = generator.valueToCode(this, 'PATH', generator.ORDER_ASSIGNMENT);
+    var code = "play_audio(" + path + ")\n";
+    return code;
+}
+
+export const actuator_mixgo_nova_play_online_audio = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_play_audio_url'] = "from mixgo_zero_voice import play_audio_url";
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_play_audio_url'] = "from mixgo_soar_voice import play_audio_url";
+    } else {
+        generator.definitions_['import_mixgo_nova_voice_play_audio_url'] = "from mixgo_nova_voice import play_audio_url";
+    }
+    var path = generator.valueToCode(this, 'PATH', generator.ORDER_ASSIGNMENT);
+    var code = "play_audio_url(" + path + ")\n";
+    return code;
+}
+
+export const actuator_mixgo_nova_onboard_music_pitch = function (block, generator) {
+    generator.definitions_['import_mixgo_nova_voice_spk_midi'] = "from mixgo_nova_voice import spk_midi";
+    var number_pitch = generator.valueToCode(block, 'pitch', generator.ORDER_ATOMIC);
+    var code = 'spk_midi.pitch(' + number_pitch + ')\n';
+    return code;
+}
+
+export const actuator_mixgo_nova_onboard_music_stop = function (block, generator) {
+    generator.definitions_['import_mixgo_nova_voice_spk_midi'] = "from mixgo_nova_voice import spk_midi";
+    var code = 'spk_midi.stop(' + ')\n';
+    return code;
+}
+
+export const set_power_output = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var index = this.getFieldValue('index');
+    var duty = generator.valueToCode(this, 'duty', generator.ORDER_ATOMIC);
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = 'onboard_bot.usben(' + index + ', ' + duty + ')\n';
+    return code;
+}
+
+export const get_power_output = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var index = this.getFieldValue('index');
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = 'onboard_bot.usben(' + index + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const set_all_power_output = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var duty = generator.valueToCode(this, 'duty', generator.ORDER_ATOMIC);
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = 'onboard_bot.usben(freq=' + duty + ')\n';
+    return code;
+}
+
+export const set_part_power_output = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var index = this.getFieldValue('index');
+    var duty = generator.valueToCode(this, 'duty', generator.ORDER_ATOMIC);
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = 'onboard_bot.usben(' + index + ', freq=' + duty + ')\n';
+    return code;
+}
+
+export const analog_keyboard_input = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var sp = generator.valueToCode(this, 'special', generator.ORDER_ATOMIC);
+    var ge = generator.valueToCode(this, 'general', generator.ORDER_ATOMIC);
+    var re = this.getFieldValue('release');
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = "onboard_bot.hid_keyboard(" + sp + ", " + ge + ", " + re + ")\n";
+    return code;
+}
+
+export const special_key = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const general_key = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const analog_mouse_input = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var wheel = generator.valueToCode(this, 'wheel', generator.ORDER_ATOMIC);
+    var re = this.getFieldValue('release');
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = "onboard_bot.hid_mouse(keys=" + key + ", move=(" + x + ", " + y + "), wheel=" + wheel + ", release=" + re + ")\n";
+    return code;
+}
+
+export const mouse_key = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const analog_keyboard_str = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var str = generator.valueToCode(this, 'str', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = "onboard_bot.hid_keyboard_str(" + str + ", delay=" + t + ")\n";
+    return code;
+}
+
+export const general_key_tuple = function (_, generator) {
+    // Create a list with any number of elements of any type.
+    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;
+    }
+    if (this.itemCount_ != 1) {
+        var code = '(' + code.join(', ') + ')';
+    } else {
+        var code = '(' + code.join(', ') + ',)';
+    }
+
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const analog_ble_keyboard_init = function (_, generator) {
+    generator.definitions_['import_ble_keyboard'] = 'from ble_hid_keyboard import Keyboard';
+    var kname = generator.valueToCode(this, 'kname', generator.ORDER_ATOMIC)
+    var code = 'ble_keyboard=Keyboard(' + kname + ')\n';
+    return code;
+}
+
+export const ble_keyboard_get_mac = function (_, generator) {
+    generator.definitions_['import_ble_keyboard'] = 'from ble_hid_keyboard import Keyboard';
+    var code = 'ble_keyboard.mac';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ble_keyboard_connect = function (_, generator) {
+    generator.definitions_['import_ble_keyboard'] = 'from ble_hid_keyboard import Keyboard';
+    var code = 'ble_keyboard.is_connected()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const analog_ble_keyboard_input = function (_, generator) {
+    var sp = generator.valueToCode(this, 'special', generator.ORDER_ATOMIC);
+    var ge = generator.valueToCode(this, 'general', generator.ORDER_ATOMIC);
+    var re = this.getFieldValue('release');
+    generator.definitions_['import_ble_keyboard'] = 'from ble_hid_keyboard import Keyboard';
+    var code = "ble_keyboard.notify_hid(" + sp + ", " + ge + ", " + re + ")\n";
+    return code;
+}
+
+export const analog_ble_keyboard_str = function (_, generator) {
+    var str = generator.valueToCode(this, 'str', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    generator.definitions_['import_ble_keyboard'] = 'from ble_hid_keyboard import Keyboard';
+    var code = "ble_keyboard.notify_str(" + str + ", delay=" + t + ")\n";
+    return code;
+}
+
+export const analog_ble_keyboard_send_battery = function (_, generator) {
+    var b = generator.valueToCode(this, 'battery', generator.ORDER_ATOMIC);
+    generator.definitions_['import_ble_keyboard'] = 'from ble_hid_keyboard import Keyboard';
+    var code = "ble_keyboard.notify_battery(" + b + ")\n";
+    return code;
+}
+
+export const analog_ble_mouse_init = function (_, generator) {
+    generator.definitions_['import_ble_mouse'] = 'from ble_hid_mouse import Mouse';
+    var name = generator.valueToCode(this, 'name', generator.ORDER_ATOMIC)
+    var code = 'ble_mouse=Mouse(' + name + ')\n';
+    return code;
+}
+
+export const ble_mouse_get_mac = function (_, generator) {
+    generator.definitions_['import_ble_mouse'] = 'from ble_hid_mouse import Mouse';
+    var code = 'ble_mouse.mac';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ble_mouse_connect = function (_, generator) {
+    generator.definitions_['import_ble_mouse'] = 'from ble_hid_mouse import Mouse';
+    var code = 'ble_mouse.is_connected()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const analog_ble_mouse_input = function (_, generator) {
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var wheel = generator.valueToCode(this, 'wheel', generator.ORDER_ATOMIC);
+    var re = this.getFieldValue('release');
+    generator.definitions_['import_ble_mouse'] = 'from ble_hid_mouse import Mouse';
+    var code = "ble_mouse.notify_hid(" + key + ", (" + x + ", " + y + "), " + wheel + ", " + re + ")\n";
+    return code;
+}
+
+export const analog_ble_mouse_send_battery = function (_, generator) {
+    var b = generator.valueToCode(this, 'battery', generator.ORDER_ATOMIC);
+    generator.definitions_['import_ble_mouse'] = 'from ble_hid_mouse import Mouse';
+    var code = "ble_mouse.notify_battery(" + b + ")\n";
+    return code;
+}
+
+export const analog_ble_keyboard_mouse_init = function (_, generator) {
+    generator.definitions_['import_HID_ble_hid'] = 'from ble_hid import HID';
+    var kname = generator.valueToCode(this, 'kname', generator.ORDER_ATOMIC)
+    var code = 'ble_hid = HID(' + kname + ')\n';
+    return code;
+}
+
+export const ble_keyboard_mouse_get_mac = function (_, generator) {
+    generator.definitions_['import_HID_ble_hid'] = 'from ble_hid import HID';
+    var code = 'ble_hid.mac';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ble_keyboard_mouse_connect = function (_, generator) {
+    generator.definitions_['import_HID_ble_hid'] = 'from ble_hid import HID';
+    var code = 'ble_hid.is_connected()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const analog_ble_keyboard_mouse_send_battery = function (_, generator) {
+    var b = generator.valueToCode(this, 'battery', generator.ORDER_ATOMIC);
+    generator.definitions_['import_HID_ble_hid'] = 'from ble_hid import HID';
+    var code = "ble_hid.battery_notify(" + b + ")\n";
+    return code;
+}
+
+export const analog_ble_keyboard_mouse_input = function (_, generator) {
+    var sp = generator.valueToCode(this, 'special', generator.ORDER_ATOMIC);
+    var ge = generator.valueToCode(this, 'general', generator.ORDER_ATOMIC);
+    var re = this.getFieldValue('release');
+    generator.definitions_['import_HID_ble_hid'] = 'from ble_hid import HID';
+    var code = "ble_hid.keyboard_notify(" + sp + ", " + ge + ", " + re + ")\n";
+    return code;
+}
+
+export const analog_ble_keyboard_mouse_str = function (_, generator) {
+    var str = generator.valueToCode(this, 'str', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    generator.definitions_['import_HID_ble_hid'] = 'from ble_hid import HID';
+    var code = "ble_hid.keyboard_str(" + str + ", delay=" + t + ")\n";
+    return code;
+}
+
+export const analog_ble_mouse_keyboard_input = function (_, generator) {
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var wheel = generator.valueToCode(this, 'wheel', generator.ORDER_ATOMIC);
+    var re = this.getFieldValue('release');
+    generator.definitions_['import_HID_ble_hid'] = 'from ble_hid import HID';
+    var code = "ble_hid.mouse_notify(" + key + ", (" + x + ", " + y + ") ," + wheel + ", " + re + ")\n";
+    return code;
+}
+//educore actuator
+export const educore_buzzer = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_speaker'] = 'from ' + version + ' import spesker';
+    var code = "speaker()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_buzzer_play_tone = function (block, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_speaker'] = 'from ' + version + ' import spesker';
+    var bu = generator.valueToCode(this, 'buzzer', generator.ORDER_ATOMIC);
+    var number_pitch = generator.valueToCode(block, 'pitch', generator.ORDER_ATOMIC);
+    var code = bu+'.tone(freq=[' + number_pitch + '])\n';
+    return code;
+}
+
+export const educore_buzzer_play_tone_time = function (block, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_speaker'] = 'from ' + version + ' import spesker';
+    var bu = generator.valueToCode(this, 'buzzer', generator.ORDER_ATOMIC);
+    var number_pitch = generator.valueToCode(block, 'pitch', generator.ORDER_ATOMIC);
+    var number_time = generator.valueToCode(block, 'time', generator.ORDER_ATOMIC);
+    var code = bu+'.tone(freq=' + number_pitch + ', dur=' + number_time + ')\n';
+    return code;
+}
+
+export const educore_buzzer_stop = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_speaker'] = 'from ' + version + ' import spesker';
+    var bu = generator.valueToCode(this, 'buzzer', generator.ORDER_ATOMIC);
+    var code = bu+'.stop()\n';
+    return code;
+}
+
+export const educore_rgb_light = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'rgb'] = 'from ' + version + ' import rgb';
+    var code = "rgb()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_neopixel_rgb = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'rgb'] = 'from ' + version + ' import rgb';
+    var rgb = generator.valueToCode(this, 'rgb', generator.ORDER_ATOMIC);
+    var value_led = generator.valueToCode(this, '_LED_', generator.ORDER_ATOMIC);
+    var value_rvalue = generator.valueToCode(this, 'RVALUE', generator.ORDER_ATOMIC);
+    var value_gvalue = generator.valueToCode(this, 'GVALUE', generator.ORDER_ATOMIC);
+    var value_bvalue = generator.valueToCode(this, 'BVALUE', generator.ORDER_ATOMIC);
+    var code = rgb+'.write(index[' + value_led + '], r=int(' + value_rvalue + '), g=int(' + value_gvalue + '), b=int(' + value_bvalue + '))\n';
+    return code;
+}
+
+export const educore_neopixel_clear = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + 'rgb'] = 'from ' + version + ' import rgb';
+    var rgb = generator.valueToCode(this, 'rgb', generator.ORDER_ATOMIC);
+    var code = rgb+'.clear()\n';
+    return code;
+}
+
+export const educore_ble_sensor_init = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_hid'] = 'from ' + version + ' import hid';
+    var n = generator.valueToCode(this, 'name', generator.ORDER_ATOMIC);
+    var code = 'hid.(name='+ n +')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_ble_sensor_connected = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_hid'] = 'from ' + version + ' import hid';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub+'.isconnected()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_ble_keyboard_input = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_keycode'] = 'from ' + version + ' import keycode';
+    var ge = generator.valueToCode(this, 'general', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub+".keyboard_send("+ ge + ")\n";
+    return code;
+}
+
+export const get_keyboard_light = function (_,generator){
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var key = this.getFieldValue('key');
+    var code = "onboard_bot.hid_keyboard_state()["+ key +']';
+    return [code,generator.ORDER_ATOMIC]
+}
+
+export const set_microphone_amplification = function (_,generator){
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var t = this.getFieldValue('times');
+    var code = "onboard_bot.mic_pga("+ t +')\n';
+    return code;
+}
+
+export const record_audio = function (_,generator){
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var str = generator.valueToCode(this, 'str', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var code = 'onboard_bot.pcm_record('+str+','+ t +')\n';
+    return code;
+}
+
+export const set_music_volume = function (_,generator){
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_music'] = 'from ' + version + ' import onboard_music';
+    var p = generator.valueToCode(this, 'percent', generator.ORDER_ATOMIC);
+    var code = 'onboard_music.set_volume('+p+')\n';
+    return code;
+}

mixly/boards/default_src/micropython/generators/ai.js

@@ -0,0 +1,36 @@
+import * as Mixly from 'mixly';
+
+export const MICROPYTHON_AI_client = function (_, generator) {
+    var ctype = this.getFieldValue('CTYPE');
+    generator.definitions_['import_baidu_speech'] = 'import baidu_speech';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var api_key = generator.valueToCode(this, 'API_KEY', generator.ORDER_ATOMIC);
+    var sound = '';
+    if (ctype == "ASR") {
+        var version = Mixly.Boards.getSelectedBoardKey().split(':')[2];
+        generator.definitions_['import_' + version + '_onboard_sound'] = "from " + version + " import onboard_sound";
+        sound += 'onboard_sound.adc' + ',';
+    }
+    var secret_key = generator.valueToCode(this, 'SECRET_KEY', generator.ORDER_ATOMIC);
+    var code = v + ' = ' + 'baidu_speech.' + ctype + '(' + sound + api_key + ', ' + secret_key + ')\n';
+    return code;
+}
+
+export const MICROPYTHON_AI_Speech_unit = function (_, generator) {
+    generator.definitions_['import_baidu_speech'] = 'import baidu_speech';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var id = generator.valueToCode(this, 'ID', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'STR', generator.ORDER_ATOMIC);
+    var code = v + '.chatbot(' + id + ',' + s + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const MICROPYTHON_AI_Speech_asr = function (_, generator) {
+    var language = this.getFieldValue('LANGUAGE');
+    generator.definitions_['import_baidu_speech'] = 'import baidu_speech';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var fn = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC) || '""';
+    var code = v + '.recognize(record_time=' + fn + ', dev_pid=' + language + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+

mixly/boards/default_src/micropython/generators/ai_cloud.js

@@ -0,0 +1,79 @@
+import { Boards } from 'mixly';
+
+export const init_xunfei_vi = function (_, generator) {
+    generator.definitions_['import_mini_xunfei'] = "import mini_xunfei";
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var id = generator.valueToCode(this, 'APPID', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'APISecret', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'APIKey', generator.ORDER_ATOMIC);
+    var code = v + ' = mini_xunfei.ASR_WebSocket(' + id + ',' + key + ',' + s +')\n';
+    return code;
+}
+
+export const init_xunfei_Spark_Ultra = function (_, generator) {
+    generator.definitions_['import_mini_xunfei'] = "import mini_xunfei";
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var id = generator.valueToCode(this, 'APPID', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'APISecret', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'APIKey', generator.ORDER_ATOMIC);
+    var m = this.getFieldValue('model');
+    var code = v + ' = mini_xunfei.LLM_WebSocket(' + id + ',' + key + ',' + s + ',"' + m + '")\n';
+    return code;
+}
+
+export const init_xunfei_Chinese_Model = function (_, generator) {
+    generator.definitions_['import_mini_xunfei'] = "import mini_xunfei";
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var id = generator.valueToCode(this, 'APPID', generator.ORDER_ATOMIC);
+    var s = generator.valueToCode(this, 'APISecret', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'APIKey', generator.ORDER_ATOMIC);
+    var hw = generator.valueToCode(this, 'HW', generator.ORDER_ATOMIC);
+    var code = v + ' = mini_xunfei.IAT_WebSocket('+id+','+key +','+s+',res_id='+hw+')\n';
+    return code;
+}
+
+export const xunfei_vi_run = function (_, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var t = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var code = v + '.run(' + t +')';
+    return [code,generator.ORDER_ATOMIC];
+}
+
+export const xunfei_Spark_Ultra_run = function (_, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var q = generator.valueToCode(this, 'qus', generator.ORDER_ATOMIC);
+    var code = v + '.run(' + q +')';
+    return [code,generator.ORDER_ATOMIC];
+}
+
+export const init_xunfei_Spark_Ultra_clr_his = function (_, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = v + '.empty_history()\n';
+    return code;
+}
+
+export const llm_set_callback = function (_, generator) {
+    var v1 = generator.valueToCode(this, "VAR1", generator.ORDER_NONE) || "None";
+    var v2 = generator.valueToCode(this, "VAR2", generator.ORDER_NONE) || "None";
+    var v3 = generator.valueToCode(this, "VAR3", generator.ORDER_NONE) || "None";
+    // var a0 = generator.valueToCode(this, "ADD0", generator.ORDER_NONE) || "None";
+    var callback = generator.variableDB_.getName(
+        generator.valueToCode(this, "callback", generator.ORDER_NONE) || "None",
+        Blockly.Procedures.NAME_TYPE
+    );
+    var code = new Array(this.itemCount_);
+    var default_value = "()";
+    for (var n = 0; n < this.itemCount_; n++) {
+        code[n] = generator.valueToCode(this, 'ADD' + n, generator.ORDER_NONE) || default_value;
+    }
+    if (this.itemCount_ > 1){
+        var code = v1 +'.function_call(' + callback + ', ' + v2 + ', ' + v3 + ', (' + code.join(', ') +'))\n';
+    }else if(this.itemCount_ == 1){
+        var code = v1 +'.function_call(' + callback + ', ' + v2 + ', ' + v3 + ', ' + code.join(', ') +')\n';
+    }else{
+        var code = v1 +'.function_call(' + callback + ', ' + v2 + ', ' + v3 +')\n';
+    }
+    
+    return code;
+}
+

mixly/boards/default_src/micropython/generators/ai_local.js

@@ -0,0 +1,642 @@
+import { Boards } from 'mixly';
+
+
+export const yesorno = function (_, generator) {
+    var code = this.getFieldValue('state');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//voice part
+export const VOICE_RECOGNITION_CONTROL = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var control = this.getFieldValue('control');
+    var code = 'onboard_bot.asr_en(' + control + ')\n';
+    return code;
+}
+
+export const CI130X_OPEN_AND_CLOSE = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var status = this.getFieldValue('status');
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mini_gx_ext_asr'] = 'from mini_gx import ext_asr';
+        var code = 'ext_asr.asr_en(' + status + ')\n';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_asr'] = 'from ' + version + ' import onboard_asr';
+        var code = 'onboard_asr.asr_en(' + status + ')\n';
+    }
+    return code;
+}
+
+export const CI130X_IDENTIFY_AND_SAVE_SANT = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mini_gx_ext_asr'] = 'from mini_gx import ext_asr';
+        var code = 'ext_asr.cmd_id()\n';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_asr'] = 'from ' + version + ' import onboard_asr';
+        var code = 'onboard_asr.cmd_id()\n';
+    }
+    return code;
+}
+
+export const CI130X_GET_WHETHER_IDENTIFY_SANT = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mini_gx_ext_asr'] = 'from mini_gx import ext_asr';
+        var cmd = this.getFieldValue('cmd');
+        var code = 'ext_asr.result(' + cmd + ')';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_asr'] = 'from ' + version + ' import onboard_asr';
+        var cmd = this.getFieldValue('cmd');
+        var code = 'onboard_asr.result(' + cmd + ')';
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const CI130X_GET_THE_RECOGNIZED_CMD_SANT = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mini_gx_ext_asr'] = 'from mini_gx import ext_asr';
+        var key = this.getFieldValue('key');
+        if (key == 'status1') {
+            var code = 'ext_asr.status()[0]';
+        } else if (key == 'status2') {
+            var code = 'ext_asr.status()[1]';
+        } else if (key == 'status3') {
+            var code = 'ext_asr.asr_en()';
+        } else {
+            var code = 'ext_asr.' + key + '()';
+        }
+    } else {
+        generator.definitions_['import_' + version + '_onboard_asr'] = 'from ' + version + ' import onboard_asr';
+        var key = this.getFieldValue('key');
+        if (key == 'status1') {
+            var code = 'onboard_asr.status()[0]';
+        } else if (key == 'status2') {
+            var code = 'onboard_asr.status()[1]';
+        } else if (key == 'status3') {
+            var code = 'ext_asr.asr_en()';
+        } else {
+            var code = 'onboard_asr.' + key + '()';
+        }
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const CI130X_BROADCAST_SANT = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mini_gx_ext_asr'] = 'from mini_gx import ext_asr';
+        var num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+        var star = this.getFieldValue('star');
+        var end = this.getFieldValue('end');
+        var code = 'ext_asr.play(' + star + ', ' + num + ', ' + end + ')\n';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_asr'] = 'from ' + version + ' import onboard_asr';
+        var num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+        var star = this.getFieldValue('star');
+        var end = this.getFieldValue('end');
+        var code = 'onboard_asr.play(' + star + ', ' + num + ', ' + end + ')\n';
+    }
+    return code;
+}
+
+export const CI130X_SET_SYSTEM_CMD_SANT = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mini_gx_ext_asr'] = 'from mini_gx import ext_asr';
+        var cmd = this.getFieldValue('cmd');
+        var code = 'ext_asr.sys_cmd(' + cmd + ')\n';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_asr'] = 'from ' + version + ' import onboard_asr';
+        var cmd = this.getFieldValue('cmd');
+        var code = 'onboard_asr.sys_cmd(' + cmd + ')\n';
+    }
+    return code;
+}
+
+export const CI130X_BROADCAST_SYSTEM_TIME = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_asr'] = 'from ' + version + ' import onboard_asr';
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'onboard_asr.play_time(detail=' + bool + ')\n';
+    return code;
+}
+
+export const CI130X_PLAY_SYSTEM_CMD_SANT = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_sant') {
+        generator.definitions_['import_sant_tts'] = 'import sant_tts';
+        var text = generator.valueToCode(this, 'text', generator.ORDER_ATOMIC) || '"你们,米思齐"';
+        var speed = this.getFieldValue('speed') || '3';
+        var code = 'sant_tts.play(' + text + ', speed=' + speed + ')\n';
+    } else if (version == 'mixgo_sowl') {
+        generator.definitions_['import_sant_tts'] = 'import sowl_tts';
+        var text = generator.valueToCode(this, 'text', generator.ORDER_ATOMIC) || '"你们,米思齐"';
+        var speed = this.getFieldValue('speed') || '3';
+        var code = 'sowl_tts.play(' + text + ', speed=' + speed + ')\n';
+    } else {
+        generator.definitions_['import_tts'] = 'import tts';
+        var text = generator.valueToCode(this, 'text', generator.ORDER_ATOMIC) || '"你们,米思齐"';
+        var speed = this.getFieldValue('speed') || '3';
+        var code = 'tts.play(' + text + ', speed=' + speed + ')\n';
+    }
+    return code;
+}
+
+//graph part
+export const CREATE_CAMERA = function (_, generator) {
+    // var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_Camera_FrameSize'] = 'from camera import Camera,FrameSize';
+    var cmd = this.getFieldValue('cmd');
+    var hm = generator.valueToCode(this, 'HM', generator.ORDER_ATOMIC);
+    var vf = generator.valueToCode(this, 'VF', generator.ORDER_ATOMIC);
+    var code = 'camera = Camera(FrameSize.' + cmd + ',hmirror=' + hm + ',vflip=' + vf + ')\n';
+    return code;
+}
+
+export const SHOOT_AND_SAVE_PICTURE = function (_, generator) {
+    var direct = generator.valueToCode(this, 'direct', generator.ORDER_ATOMIC);
+    var code = 'camera.snapshot(' + direct + ')\n';
+    return code;
+}
+
+export const GET_IMAGE_AND_SAVE = function (_, generator) {
+    generator.definitions_['camera_import_Image'] = 'from camera import Image';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var direct = generator.valueToCode(this, 'direct', generator.ORDER_ATOMIC);
+    var q = generator.valueToCode(this, 'quality', generator.ORDER_ATOMIC);
+    var a = this.getFieldValue('angle');
+    var code = 'Image.save(' + sub + ',path=' + direct + ',quality=' + q + ',rotation=' + a + ')\n';
+    return code;
+}
+
+export const OPEN_IMAGE = function (_, generator) {
+    generator.definitions_['camera_import_Image'] = 'from camera import Image';
+    var direct = generator.valueToCode(this, 'direct', generator.ORDER_ATOMIC);
+    var a = this.getFieldValue('angle');
+    var w = generator.valueToCode(this, 'w', generator.ORDER_ATOMIC);
+    var h = generator.valueToCode(this, 'h', generator.ORDER_ATOMIC);
+    var code = 'Image.open(path=' + direct + ',rotation=' + a + ',scale_width=' + w + ',scale_height=' + h + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_IMAGE_FROM_NET = function (_, generator) {
+    generator.definitions_['camera_import_Image'] = 'from camera import Image';
+    var direct = generator.valueToCode(this, 'direct', generator.ORDER_ATOMIC);
+    var a = this.getFieldValue('angle');
+    var w = generator.valueToCode(this, 'w', generator.ORDER_ATOMIC);
+    var h = generator.valueToCode(this, 'h', generator.ORDER_ATOMIC);
+    var code = 'Image.download(url=' + direct + ', rotation=' + a + ', scale_width=' + w + ', scale_height=' + h + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const CAMERA_LOOGOUT = function () {
+    var code = 'camera.deinit()\n';
+    return code;
+}
+
+export const GET_PICTURE_DATA_EXACT = function (_, generator) {
+    // var kind = this.getFieldValue('kind');
+    var code = 'camera.capture()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_PICTURE_WIDTH_HEIGHT_DEVICE = function (_, generator) {
+    var kind = this.getFieldValue('kind');
+    var code = 'camera.' + kind + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const CONVERT_IMAGE_TO_JPG = function (_, generator) {
+    generator.definitions_['camera_import_Image'] = 'from camera import Image';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var kind = this.getFieldValue('kind');
+    var q = generator.valueToCode(this, 'quality', generator.ORDER_ATOMIC);
+    var code = 'Image.convert(' + sub + ', formats=' + kind + ', quality=' + q + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_PICTURE_DATA_WHS = function (_, generator) {
+    generator.definitions_['camera_import_Image'] = 'from camera import Image';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var kind = this.getFieldValue('kind');
+    var code = sub + '.' + kind;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const SCREEN_SHOW_CAM_GRAPH_SHOOT = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_tft'] = "from " + version + " import onboard_tft";
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'onboard_tft.display(' + sub + ', sync=' + bool + ')\n';
+    return code;
+}
+
+export const SCREEN_SHOW_CAM_GRAPH_SHOOT_LOCATION = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_tft'] = "from " + version + " import onboard_tft";
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'onboard_tft.display(' + sub + ',x=' + x + ',y=' + y + ', sync=' + bool + ')\n';
+    return code;
+}
+
+export const SCREEN_DISPLAY_IMAGE = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_tft'] = "from " + version + " import onboard_tft";
+    var direct = generator.valueToCode(this, 'direct', generator.ORDER_ATOMIC);
+    var a = this.getFieldValue('angle');
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'onboard_tft.display(' + direct + ',rotation=' + a + ',sync=' + bool + ')\n';
+    return code;
+}
+
+export const SCREEN_DISPLAY_IMAGE_LOCATION = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_tft'] = "from " + version + " import onboard_tft";
+    var direct = generator.valueToCode(this, 'direct', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var a = this.getFieldValue('angle');
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'onboard_tft.display(' + direct + ',x=' + x + ',y=' + y + ',rotation=' + a + ',sync=' + bool + ')\n';
+    return code;
+}
+
+export const GET_SCREEN_IMAGE = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_tft'] = "from " + version + " import onboard_tft";
+    var code = 'onboard_tft.screenshot()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_SCREEN_IMAGE_SIZE = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_tft'] = "from " + version + " import onboard_tft";
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var w = generator.valueToCode(this, 'w', generator.ORDER_ATOMIC);
+    var h = generator.valueToCode(this, 'h', generator.ORDER_ATOMIC);
+    var code = 'onboard_tft.screenshot(x=' + x + ',y=' + y + ',w=' + w + ',h=' + h + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const AI_CAMERA_INIT = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var cmd = this.getFieldValue('kind');
+    var width = generator.valueToCode(this, 'WIDTH', generator.ORDER_ATOMIC);
+    var height = generator.valueToCode(this, 'HEIGHT', generator.ORDER_ATOMIC);
+    var code = sub + ' = esp_dl.' + cmd + '(width=' + width + ', height=' + height + ')\n';
+    return code;
+}
+
+export const MODEL_INIT_WIDTH = function (_, generator) {
+    var width = this.getFieldValue('width');
+    var code = width;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const MODEL_INIT_HEIGHT = function (_, generator) {
+    var height = this.getFieldValue('height');
+    var code = height;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const AI_CAMERA_INIT_FACERECOGNIZE = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var path = generator.valueToCode(this, 'PATH', generator.ORDER_ATOMIC);
+    var width = generator.valueToCode(this, 'WIDTH', generator.ORDER_ATOMIC);
+    var height = generator.valueToCode(this, 'HEIGHT', generator.ORDER_ATOMIC);
+    var code = sub + ' = esp_dl.FaceRecognizer(width=' + width + ', height=' + height + ', db_path=' + path + ')\n';
+    return code;
+}
+
+export const MODEL_LOGOUT = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = 'del ' + sub + '\n';
+    return code;
+}
+
+export const MODEL_RUN = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var frame = generator.valueToCode(this, 'FRAME', generator.ORDER_ATOMIC);
+    var code = sub + '.run(' + frame + '.image)';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const MODEL_WHETHER_RUN_SUCCEED = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+
+    var code = 'esp_dl.analyze(' + sub + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_HOW_MUCH_RECOGNITION = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.analyze(' + sub + ',"len")';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_NO_RECOGNITION = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var no = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.analyze(' + sub + ',"data",' + no + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_NO_XY_RECOGNITION = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var no = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    var coord = this.getFieldValue('coord');
+    if (coord == "all") {
+        var code = 'esp_dl.analyze(' + sub + ',"box",' + no + ')';
+    } else {
+        var code = 'esp_dl.analyze(' + sub + ',"box",' + no + ')[' + coord + ']';
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_NO_XY_RECOGNITION_FACE = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var no = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    var part = this.getFieldValue('part');
+    if (part == "all") {
+        var code = 'esp_dl.analyze(' + sub + ',"features",' + no + ')';
+    } else {
+        var code = 'esp_dl.analyze(' + sub + ',"features",' + no + ')' + part;
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_NO_CAT_OR_FACE_RECOGNITION = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var no = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.analyze(' + sub + ',"score",' + no + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const Register_color_recognition_fixed = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var color = this.getFieldValue('color');
+    var area = generator.valueToCode(this, 'AREA', generator.ORDER_ATOMIC);
+    if (color == "red") {
+        var code = sub + '.register_color((170, 100, 100), (10, 255, 255),"' + color + '", ' + area + ')\n';
+    } else if (color == "green") {
+        var code = sub + '.register_color((35, 100, 100), (85, 255, 255),"' + color + '",' + area + ')\n';
+    } else if (color == "blue") {
+        var code = sub + '.register_color((100, 100, 100), (130, 255, 255),"' + color + '", ' + area + ')\n';
+    } else if (color == "yellow") {
+        var code = sub + '.register_color((20, 100, 100), (35, 255, 255),"' + color + '", ' + area + ')\n';
+    } else if (color == "cyan") {
+        var code = sub + '.register_color((85, 100, 100), (100, 255, 255),"' + color + '", ' + area + ')\n';
+    } else if (color == "purple") {
+        var code = sub + '.register_color((130, 100, 100), (150, 255, 255),"' + color + '", ' + area + ')\n';
+    } else if (color == "black") {
+        var code = sub + '.register_color((0, 0, 0), (180, 255, 50),"' + color + '", ' + area + ')\n';
+    } else if (color == "white") {
+        var code = sub + '.register_color((0, 0, 200), (180, 50, 255),"' + color + '", ' + area + ')\n';
+    }
+    return code;
+}
+
+export const Register_color_recognition = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var min = generator.valueToCode(this, 'MIN', generator.ORDER_ATOMIC);
+    var max = generator.valueToCode(this, 'MAX', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'COLOR', generator.ORDER_ATOMIC);
+    var area = generator.valueToCode(this, 'AREA', generator.ORDER_ATOMIC);
+    var code = sub + '.register_color(' + min + ', ' + max + ', ' + color + ', ' + area + ')\n';
+    return code;
+}
+
+export const REGISTER_NEW_FACE = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var image = generator.valueToCode(this, 'IMAGE', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'NAME', generator.ORDER_ATOMIC);
+    var code = sub + '.enroll(' + image + '.image, name=' + name + ', validate = 1)';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const DELETE_FACE_FROM_DATABASE = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var id = generator.valueToCode(this, 'ID', generator.ORDER_ATOMIC);
+    var code = sub + '.delete_face(' + id + ')\n';
+    return code;
+}
+
+export const DELETE_FACE_ALL = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + '.clear_face()\n';
+    return code;
+}
+
+export const PRINT_FACE_DATABASE = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + '.print_database()\n';
+    return code;
+}
+
+export const GET_QR_CODE_RECOGNITION_DATA = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.simple_run(' + sub + ', camera, "data", color=0xF800, sync=' + bool + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_PICTURE_RECOGNITION_DATA = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.simple_run(' + sub + ', camera, "data", color=0xF800, sync=' + bool + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_COLOR_DETECTION_NUM = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.simple_run(' + sub + ', camera, "len", color=0xF800, sync=' + bool + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// export const GET_COLOR_DETECTION_LOCATION = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var num = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+//     var color = this.getFieldValue('color');
+//     var code = sub + '.color_detection('+ color +",'pos',"+ num +')';
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+export const GET_CAT_FACE_DETECTION_NUM = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.simple_run(' + sub + ', camera, "len", color=0xF800, sync=' + bool + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// export const GET_CAT_FACE_DETECTION_LOCATION = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var num = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+//     var code = sub + ".cat_detection('pos',"+ num +')';
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+export const GET_HUMAN_DETECTION_NUM = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.simple_run(' + sub + ', camera, "len", color=0xF800, sync=' + bool + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_FACE_DETECTION_NUM = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.simple_run(' + sub + ', camera, "len", color=0xF800, sync=' + bool + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const GET_FACE_DETECTION_NAME = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl'
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var bool = generator.valueToCode(this, 'boolean', generator.ORDER_ATOMIC);
+    var code = 'esp_dl.simple_run(' + sub + ', camera, "person", "name", color=0xF800, sync=' + bool + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// export const GET_FACE_DETECTION_LOCATION = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var num = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+//     var code = sub + ".face_detection('pos',"+ num +')';
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+// export const GET_FACE_DETECTION_KEYPOINT_LOCATION = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var num = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+//     var kp = this.getFieldValue('kp');
+//     var code = sub + ".face_detection('keypoint',"+ num +','+ kp +')';
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+// export const GET_FACE_RECOGNITION_ID = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var code = sub + ".face_recognition('len')";
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+// export const GET_FACE_RECOGNITION_ID_LOCATION = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var num = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+//     var code = sub + ".face_recognition('pos',"+ num +')';
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+// export const GET_FACE_RECOGNITION_ID_KEYPOINT_LOCATION = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var num = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+//     var kp = this.getFieldValue('kp');
+//     var code = sub + ".face_recognition('keypoint',"+ num +','+ kp +')';
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+export const GET_NO_FACE_RECOGNITION_INFO = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    var kind = this.getFieldValue('kind');
+    var code = "esp_dl.analyze(" + sub + ', "person",' + num + ')["' + kind + '"]';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// export const PEOPLE_FACE_ENROLL = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var code = sub + '.face_enroll()';
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+// export const DELETE_PEOPLE_FACE_ID = function (_, generator) {
+//     var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+//     var id = generator.valueToCode(this, 'ID', generator.ORDER_ATOMIC);
+//     var code = sub + '.face_delete('+ id +')\n';
+//     return code;
+// }
+
+export const AI_STOP_ACQUISITION = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + '.stop()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const MIXIO_REPORT_IMAGE_DATA = function (_, generator) {
+    generator.definitions_['import_base64'] = 'import base64';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = 'mixiot.image_base64(' + sub + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//simplified part
+export const CREATE_CAMERA_SIMPLE = function (_, generator) {
+    generator.definitions_['import_Camera_FrameSize'] = 'from camera import Camera,FrameSize';
+    var cmd = this.getFieldValue('cmd');
+    var code = 'camera = Camera(FrameSize.' + cmd + ', hmirror=False,vflip=False)\n';
+    return code;
+}
+
+export const AI_CAMERA_INIT_SIMPLE = function (_, generator) {
+    generator.definitions_['import_esp_dl'] = 'import esp_dl';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var cmd = this.getFieldValue('kind');
+    if (cmd == "FaceRecognizer") {
+        var code = sub + ' = esp_dl.' + cmd + '(width=camera.get_pixel_width(), height=camera.get_pixel_height() , db_path="face.db")\n';
+    } else {
+        var code = sub + ' = esp_dl.' + cmd + '(width=camera.get_pixel_width(), height=camera.get_pixel_height())\n';
+    }
+    return code;
+}
+
+export const Register_color_recognition_fixed_SIMPLE = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var color = this.getFieldValue('color');
+    if (color == "red") {
+        var code = sub + '.register_color((170, 100, 100), (10, 255, 255),"' + color + '")\n';
+    } else if (color == "green") {
+        var code = sub + '.register_color((35, 100, 100), (85, 255, 255),"' + color + '")\n';
+    } else if (color == "blue") {
+        var code = sub + '.register_color((100, 100, 100), (130, 255, 255),"' + color + '")\n';
+    } else if (color == "yellow") {
+        var code = sub + '.register_color((20, 100, 100), (35, 255, 255),"' + color + '")\n';
+    } else if (color == "cyan") {
+        var code = sub + '.register_color((85, 100, 100), (100, 255, 255),"' + color + '")\n';
+    } else if (color == "purple") {
+        var code = sub + '.register_color((130, 100, 100), (150, 255, 255),"' + color + '")\n';
+    } else if (color == "black") {
+        var code = sub + '.register_color((0, 0, 0), (180, 255, 50),"' + color + '")\n';
+    } else if (color == "white") {
+        var code = sub + '.register_color((0, 0, 200), (180, 50, 255),"' + color + '")\n';
+    }
+    return code;
+}
+
+export const REGISTER_NEW_FACE_SIMPLE = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'NAME', generator.ORDER_ATOMIC);
+    var code = sub + '.enroll(camera.capture().image, name=' + name + ', validate = 1)';
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/ai_sensor.js

@@ -0,0 +1,283 @@
+export const ai_sensor_use_uart_init = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = v + '=mixgo_ai.AI(' + key + ', quick=1)\n';
+    return code;
+}
+
+export const ai_sensor_qrcode_lite = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var sub = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var type = this.getFieldValue('TYPE');
+    var code = sub + '.find_' + type + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_config = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var rx = generator.valueToCode(this, 'RX', generator.ORDER_ATOMIC);
+    var tx = generator.valueToCode(this, 'TX', generator.ORDER_ATOMIC);
+    var dropdown_uart = this.getFieldValue('mode');
+    var code = v + '.configure(' + tx + ', ' + rx + ', restart=' + dropdown_uart + ')\n';
+    return code;
+}
+
+export const ai_sensor_rgb = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var led1 = generator.valueToCode(this, 'led1', generator.ORDER_ATOMIC);
+    var led2 = generator.valueToCode(this, 'led2', generator.ORDER_ATOMIC);
+    var code = v + '.led_rgb(' + led1 + ', ' + led2 + ')\n';
+    return code;
+}
+
+export const ai_sensor_qrcode = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_qrcodes = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.find_qrcodes()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_barcode = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_barcodes = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.find_barcodes()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_tag = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_tags = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.find_apriltags()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_line = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_lines = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var v3 = generator.valueToCode(this, 'VAR3', generator.ORDER_ATOMIC);
+    var code = v + '.find_lines(' + v1 + ', ' + v2 + ', ' + v3 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_circle = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_circles = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var v3 = generator.valueToCode(this, 'VAR3', generator.ORDER_ATOMIC);
+    var code = v + '.find_circles(' + v1 + ', ' + v2 + ', ' + v3 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_rect = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_rects = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var code = v + '.find_rects(' + v1 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_color = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_colors = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.find_colors()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_color_chases_result = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_color_chases = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var v3 = generator.valueToCode(this, 'VAR3', generator.ORDER_ATOMIC);
+    var code = v + '.color_track(' + v1 + ', ' + v2 + ', ' + v3 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_ailocal_train = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var v3 = generator.valueToCode(this, 'VAR3', generator.ORDER_ATOMIC);
+    var v4 = generator.valueToCode(this, 'VAR4', generator.ORDER_ATOMIC);
+    var code = v + '.ailocal_train(' + v1 + ', ' + v2 + ', ' + v3 + ', ' + v4 + ')\n';
+    return code;
+}
+
+export const ai_sensor_ailocal_class = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var v4 = generator.valueToCode(this, 'VAR4', generator.ORDER_ATOMIC);
+    var code = v + '.ailocal_class(' + v1 + ', ' + v2 + ', ' + v4 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_ailocal_class_result = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_audio_record = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var code = v + '.audio_record(path=' + v1 + ', times=' + v2 + ')\n';
+    return code;
+}
+
+export const ai_sensor_audio_play = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var code = v + '.audio_play(path=' + v1 + ', volume=' + v2 + ')\n';
+    return code;
+}
+
+export const ai_sensor_yolo_recognize = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var v4 = generator.valueToCode(this, 'VAR4', generator.ORDER_ATOMIC);
+    var code = v + '.yolo_recognize(' + v1 + ', ' + v2 + ', ' + v4 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_yolo_recognize_result = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_asr_recognize = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var v1 = generator.valueToCode(this, 'VAR1', generator.ORDER_ATOMIC);
+    var v2 = generator.valueToCode(this, 'VAR2', generator.ORDER_ATOMIC);
+    var code = v + '.asr_recognize(' + v1 + ', threshold=' + v2 + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_licenseplate = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_licenseplates = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.find_licenseplate()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_face = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_classifier_faces = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.face_detect()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ai_sensor_20object = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    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 ai_sensor_find_20objects = function (_, generator) {
+    generator.definitions_['import_mixgo_ai'] = 'import mixgo_ai';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.find_20object()';
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/blynk.js

@@ -0,0 +1,222 @@
+// Blynk 第二版
+// Blynk 自定义终端部件 Terminal
+export const mpython_blynk_terminal_widget_vpin = function (_, generator) {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+    var virtual_pin = generator.valueToCode(this, 'virtual_pin', generator.ORDER_ATOMIC);
+
+    generator.functions_['terminal_widget_vpin_' + virtual_pin] =
+        `
+ALLOWED_COMMANDS_LIST = ['ls', 'lsusb', 'ip a', 'ip abc']
+
+@blynk.handle_event('write V${virtual_pin}')
+def write_handler(pin, _values):
+    header = ''
+    result = ''
+    delimiter = '{}\\n'.format('=' * 30)
+    if _values and _values[0] in ALLOWED_COMMANDS_LIST:
+        cmd_params = _values[0].split(' ')
+        try:
+            result = subprocess.check_output(cmd_params).decode('utf-8')
+            header = '[output]\\n'
+        except subprocess.CalledProcessError as exe_err:
+            header = '[error]\\n'
+            result = 'Return Code: {}\\n'.format(exe_err.returncode)
+        except Exception as g_err:
+            print("Command caused '{}'".format(g_err))
+    elif _values and _values[0] == 'help':
+        header = '[help -> allowed commands]\\n'
+        result = '{}\\n'.format('\\n'.join(ALLOWED_COMMANDS_LIST))
+
+    # communicate with terminal if help or some allowed command
+    if result:
+        output = '{}{}{}{}'.format(header, delimiter, result, delimiter)
+        print(output)
+        blynk.virtual_write(pin, output)
+        blynk.virtual_write(pin, '\\n')
+`
+
+    var code = '';
+    return code;
+}
+
+// Blynk 同步虚拟管脚的状态
+export const mpython_blynk_sync_virtual = function (_, generator) {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+    var virtual_pin = generator.valueToCode(this, 'virtual_pin', generator.ORDER_ATOMIC);
+
+    var code = 'blynk.virtual_sync(' + virtual_pin + ')\n';
+    return code;
+}
+
+// 斷開连接 Blynk
+export const mpython_blynk_on_disconnected = function (_, generator) {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+
+    var branch = generator.statementToCode(this, 'DO');
+    branch = generator.addLoopTrap(branch, this.id) || generator.PASS;
+
+    generator.definitions_['blynk_on_disconnected'] =
+        '@blynk.handle_event("disconnect")\n' +
+        'def connect_handler():\n' +
+        "    print('Blynk disconnected')\n" + branch;
+
+    return '';
+}
+
+// 连接上 Blynk
+export const mpython_blynk_on_connected = function (_, generator) {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+
+    var branch = generator.statementToCode(this, 'DO');
+    branch = generator.addLoopTrap(branch, this.id) || generator.PASS;
+
+    generator.definitions_['blynk_on_connected'] =
+        '@blynk.handle_event("connect")\n' +
+        'def connect_handler():\n' +
+        "    print('Blynk connected')\n" + branch;
+
+    return '';
+}
+
+// Blynk 定时器的进程生效并运行
+export const mpython_blynktimer_run = function () {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+    // generator.definitions_['import_blynktimer'] = 'import blynktimer';
+
+    var code = 'blynk_timer.run()\n';
+    return code;
+}
+
+// Blynk 进程生效并运行
+export const mpython_blynk_run = function () {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+
+    var code = 'blynk.run()\n';
+    return code;
+}
+
+// Blynk APP 显示通知
+export const mpython_blynk_app_notify = function (_, generator) {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+    var notification = generator.valueToCode(this, 'notification', generator.ORDER_ATOMIC);
+
+    var code = 'blynk.notify(' + notification + ')\n';
+    return code;
+}
+
+// 停止 Blynk 定时器 %1
+export const mpython_blynk_stop_timers = function (_, generator) {
+    generator.definitions_['import_blynktimer'] = 'import blynktimer';
+    generator.definitions_['def_blynktimer'] = 'blynk_timer = blynktimer.Timer(no_timers_err=False)';
+
+    var timer_num = generator.valueToCode(this, 'timer_num', generator.ORDER_ATOMIC);
+    var code = `blynk_timer.stop('${timer_num}_blynk_timer${timer_num}')` + '\n';
+
+    return code;
+}
+
+// 可用的 Blynk 定时器
+export const mpython_blynk_get_timers = function (_, generator) {
+    generator.definitions_['import_blynktimer'] = 'import blynktimer';
+    generator.definitions_['def_blynktimer'] = 'blynk_timer = blynktimer.Timer(no_timers_err=False)';
+
+    var code = `blynk_timer.get_timers()`;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//blynk定时器
+export const mpython_blynktimer = function (_, generator) {
+    generator.definitions_['import_blynktimer'] = 'import blynktimer';
+
+    var Num = generator.valueToCode(this, 'Num', generator.ORDER_ATOMIC);
+    var period = generator.valueToCode(this, 'period', generator.ORDER_ATOMIC);
+    var Timer_mode = this.getFieldValue('Timer_mode');
+
+    var branch = generator.statementToCode(this, 'DO');
+    branch = generator.addLoopTrap(branch, this.id) || generator.PASS;
+
+    generator.definitions_['def_blynktimer'] = 'blynk_timer = blynktimer.Timer(no_timers_err=False)';
+
+    generator.definitions_['blynktimer_event' + Num] =
+        `
+@blynk_timer.register(interval=${period}, run_once=${Timer_mode})
+def blynk_timer${Num}():
+`
+        + branch;
+    return '';
+}
+
+// 发送数据 %1 到 Bylnk APP 的虚拟管脚 %2
+export const mpython_blynk_sensor_data_to_app = function (_, generator) {
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+    var sensor_data = generator.valueToCode(this, 'sensor_data', generator.ORDER_ATOMIC);
+    var virtual_pin = generator.valueToCode(this, 'virtual_pin', generator.ORDER_ATOMIC);
+    var code = 'blynk.virtual_write(' + virtual_pin + ', ' + sensor_data + ')\n';
+    return code;
+}
+
+// 从 Bylnk APP 获取虚拟管脚 %1 的值
+export const mpython_blynk_app_data = function (_, generator) {
+
+    // generator.definitions_['import_BlynkLib'] = 'import blynklib';
+    var virtual_pin = generator.valueToCode(this, 'virtual_pin', generator.ORDER_ATOMIC);
+
+    var branch = generator.statementToCode(this, 'DO');
+    branch = generator.addLoopTrap(branch, this.id) || generator.PASS;
+
+    generator.definitions_['blynk_VIRTUAL_WRITE_' + virtual_pin] =
+        "@blynk.handle_event('write V" + virtual_pin + "')\n" +
+        'def write_virtual_pin_handler(pin, _value):\n' +
+        '    for i in range(0, len(_value)):\n' +
+        '        try: _value[i] = eval(_value[i])\n' +
+        '        except: pass\n' +
+        '    if len(_value) == 1: _value = _value[0]\n' + branch;
+    //'    print('+'"v' + virtual_pin + '_value: {}".format(_value))\n'
+    // var code = 'blynk.run()\n';
+    return '';
+}
+
+// 向 %1 发邮件  主题 %2 正文 %3
+export const mpython_blynk_email = function (_, generator) {
+    var body = generator.valueToCode(this, 'body', generator.ORDER_ATOMIC);
+    var subject = generator.valueToCode(this, 'subject', generator.ORDER_ATOMIC);
+    var TargetEmail = generator.valueToCode(this, 'TargetEmail', generator.ORDER_ATOMIC);
+
+    var code = `blynk.email(${TargetEmail}, ${subject}, ${body})` + '\n';
+    return code;
+}
+
+// 给虚拟管脚添加   属性 %1 值 %2
+export const mpython_blynk_set_property = function (_, generator) {
+    var attribute_value = generator.valueToCode(this, 'attribute_value', generator.ORDER_ATOMIC);
+    var attribute_name = generator.valueToCode(this, 'attribute_name', generator.ORDER_ATOMIC);
+    var code = `blynk.set_property(pin, ${attribute_name}, ${attribute_value})` + '\n';
+    return code;
+}
+
+// Bylnk设置
+export const mpython_blynk_setup = function (_, generator) {
+    generator.definitions_['import_BlynkLib'] = 'import blynklib';
+    var server = generator.valueToCode(this, 'server', generator.ORDER_ATOMIC);
+    var auth = generator.valueToCode(this, 'auth', generator.ORDER_ATOMIC);
+    var port = generator.valueToCode(this, 'port', generator.ORDER_ATOMIC);
+
+    generator.definitions_['mpython_blynk_setup'] =
+        "blynk = blynklib.Blynk(" + auth + ", server=" + server + ", port=" + port + ")";
+
+    generator.definitions_['blynk_on_connected'] =
+        `
+@blynk.handle_event("connect")
+def connect_handler():
+    print('Blynk connected')
+`
+
+    generator.definitions_['blynk_on_disconnected'] =
+        `
+@blynk.handle_event("disconnect")
+def connect_handler():
+    print('Blynk disconnected')
+`
+
+    return '';
+}

mixly/boards/default_src/micropython/generators/cc_g1.js

@@ -0,0 +1,25 @@
+export const cc_g1_read_bat = function (_, generator) {
+    generator.definitions_['import_cc_g1'] = 'from cc_g1 import handle';
+    var code = 'handle.read_bat()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const cc_g1_read_joystick = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    generator.definitions_['import_cc_g1'] = 'from cc_g1 import handle';
+    var code = 'handle.read_joystick()' + v + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const cc_g1_read_key = function (_, generator) {
+    var v = this.getFieldValue('VAR');
+    generator.definitions_['import_cc_g1'] = 'from cc_g1 import handle';
+    var code = 'handle.read_key(' + v + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const cc_g1_turnoff = function (_, generator) {
+    generator.definitions_['import_cc_g1'] = 'from cc_g1 import handle';
+    var code = 'handle.shutdown()';
+    return code;
+}

mixly/boards/default_src/micropython/generators/ce_go.js

@@ -0,0 +1,286 @@
+import * as Mixly from 'mixly';
+
+export const ce_go_light_number = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    }
+    var code = 'car.' + this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ce_go_led_bright = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    }
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var bright = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = "car.setonoff(" + op + ", " + bright + ")\n";
+    return code;
+}
+
+export const ce_go_get_led_bright = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    }
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var code = "car.getrightness(" + op + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ce_go_get_led_state = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    }
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var code = "car.getonoff(" + op + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ce_go_led_brightness = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    }
+    var op = generator.valueToCode(this, 'led', generator.ORDER_ATOMIC);
+    var flag = generator.valueToCode(this, 'bright', generator.ORDER_ATOMIC);
+    var code = "car.setbrightness(" + op + ", " + flag + ")\n";
+    return code;
+}
+
+export const ce_go_stepper_keep = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    }
+    var v = this.getFieldValue('VAR');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ASSIGNMENT);
+    var code = 'car.move("' + v + '", ' + speed + ")\n";
+    return code;
+}
+
+export const ce_go_stepper_stop = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    }
+    var v = this.getFieldValue('VAR');
+    var code = 'car.move("' + v + '")\n';
+    return code;
+}
+
+export const ce_go_dc_motor = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_car'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_car'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_car'] = 'from mini_go import car';
+    }
+    var wheel = this.getFieldValue('wheel');
+    var v = this.getFieldValue('direction');
+    if (wheel == 0) {
+        if (v == 'CW') { v = 'CCW' }
+        else if (v == 'CCW') { v = 'CW' }
+    }
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = "car.motor(car.MOTO[" + wheel + '], "' + v + '", ' + speed + ")\n";
+    return code;
+}
+
+export const ce_go_hall_attachInterrupt = function (_, generator) {
+    var dropdown_mode = this.getFieldValue('mode');
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_hall_' + dropdown_mode] = 'from me_go import hall_' + dropdown_mode;
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_hall_' + dropdown_mode] = 'from ce_go import hall_' + dropdown_mode;
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_hall' + dropdown_mode] = 'from mini_go import hall_' + dropdown_mode;
+    }
+    var atta = generator.valueToCode(this, 'DO', generator.ORDER_ATOMIC);
+    var code = 'hall_' + dropdown_mode + '.irq_cb(' + atta + ')\n'
+    return code;
+}
+
+export const ce_go_hall_initialize = function (_, generator) {
+    var dropdown_mode = this.getFieldValue('mode');
+    var args = this.getFieldValue('args');
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_hall_' + dropdown_mode] = 'from me_go import hall_' + dropdown_mode;
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_hall_' + dropdown_mode] = 'from ce_go import hall_' + dropdown_mode;
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_hall' + dropdown_mode] = 'from mini_go import hall_' + dropdown_mode;
+    }
+    var num = generator.valueToCode(this, 'num', generator.ORDER_ATOMIC);
+    if (args == 'all') {
+        var code = 'hall_' + dropdown_mode + '.initial(' + 'turns' + '=' + num + ', distance=' + num + ')\n'
+        return code;
+    }
+    var code = 'hall_' + dropdown_mode + '.initial(' + args + '=' + num + ')\n'
+    return code;
+}
+
+export const ce_go_hall_data = function (_, generator) {
+    var dropdown_mode = this.getFieldValue('mode');
+    var args = this.getFieldValue('args');
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_hall_' + dropdown_mode] = 'from me_go import hall_' + dropdown_mode;
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_hall_' + dropdown_mode] = 'from ce_go import hall_' + dropdown_mode;
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_hall' + dropdown_mode] = 'from mini_go import hall_' + dropdown_mode;
+    }
+    var code = 'hall_' + dropdown_mode + '.' + args + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ce_go_pin_near_line = function (_, generator) {
+    var key = this.getFieldValue('key');
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_hall'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_hall'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_hall'] = 'from mini_go import car';
+    }
+    var code = 'car.patrol()' + key + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ce_go_pin_near = function (_, generator) {
+    var key = this.getFieldValue('key');
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_hall'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_hall'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_hall'] = 'from mini_go import car';
+    }
+    var code = 'car.obstacle()' + key + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ce_go_pin_near_state_change = function (_, generator) {
+    var key = this.getFieldValue('key');
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_hall'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_hall'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_hall'] = 'from mini_go import car';
+    }
+    var code = 'car.ir_mode(car.' + key + ')\n';
+    return code;
+}
+
+export const sensor_mixgome_eulerangles = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_mixgo_me_onboard_mxc6655xa'] = "from mixgo_me import onboard_mxc6655xa";
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_mixgo_ce_onboard_mxc6655xa'] = "from mixgo_ce import onboard_mxc6655xa";
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_onboard_mxc6655xa'] = 'from mini_go import onboard_mxc6655xa';
+    }
+    var angle = this.getFieldValue('angle');
+    var code = 'onboard_mxc6655xa.eulerangles(upright=True)' + angle;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ce_go_pin_light = function (_, generator) {
+    var key = this.getFieldValue('key');
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    if (version == "mixgo_me" || version == "mixgo_cc") {
+        generator.definitions_['import_me_go_hall'] = 'from me_go import car';
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_ce_go_hall'] = 'from ce_go import car';
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_mini_go_hall'] = 'from mini_go import car';
+    }
+    var code = 'car.light()' + key + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//educore car
+
+export const educore_car = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_car'] = 'from ' + version + ' import car';
+    var code = 'car()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_car_stepper_keep = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_car'] = 'from ' + version + ' import car';
+    var car = generator.valueToCode(this, 'car', generator.ORDER_ASSIGNMENT);
+    var v = this.getFieldValue('VAR');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ASSIGNMENT);
+    var code = car + '.' + v + '(' + speed + ")\n";
+    return code;
+}
+
+export const educore_car_stepper_stop = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_car'] = 'from ' + version + ' import car';
+    var car = generator.valueToCode(this, 'car', generator.ORDER_ASSIGNMENT);
+    var v = this.getFieldValue('VAR');
+    var code = car + '.' + v + "()\n";
+    return code;
+}
+
+export const educore_car_pin_near_line = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_car'] = 'from ' + version + ' import car';
+    var car = generator.valueToCode(this, 'car', generator.ORDER_ASSIGNMENT);
+    var key = this.getFieldValue('key');
+    var code = car + '.get_itr_dnum(' + key + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_car_pin_near = function (_, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_car'] = 'from ' + version + ' import car';
+    var car = generator.valueToCode(this, 'car', generator.ORDER_ASSIGNMENT);
+    var code = car + '.get_distance()';
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/communicate.js

@@ -0,0 +1,613 @@
+import * as Blockly from 'blockly/core';
+import * as Mixly from 'mixly';
+
+export const communicate_i2c_onboard = function (block, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_i2c'] = 'from ' + version + ' import onboard_i2c';
+    var code = 'onboard_i2c';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_spi_onboard = function (block, generator) {
+    var version = Mixly.Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version + '_onboard_i2c'] = 'from ' + version + ' import onboard_spi';
+    var code = 'onboard_spi';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_i2c_init = function (block, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin1 = generator.valueToCode(this, 'RX', generator.ORDER_ATOMIC);
+    var dropdown_pin2 = generator.valueToCode(this, 'TX', generator.ORDER_ATOMIC);
+    var freq = generator.valueToCode(this, 'freq', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    return "" + sub + " = machine.SoftI2C(scl = machine.Pin(" + dropdown_pin2 + "), sda=machine.Pin(" + dropdown_pin1 + "), freq=" + freq + ")\n";
+}
+
+export const communicate_i2c_read = function (block, 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 (block, 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 (block, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return ["" + name + ".scan()", generator.ORDER_ATOMIC];
+}
+
+export const communicate_i2c_master_read = function (block, 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 (block, 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 (block, 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 (block, 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 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.SoftSPI(baudrate=" + freq + ", sck=machine.Pin(" + sck + "), mosi=machine.Pin(" + mosi + "), miso=machine.Pin(" + miso + "))\n";
+}
+
+export const communicate_spi_set = function (block, generator) {
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    return "spi.init(baudrate=" + data + ")\n";
+}
+
+export const communicate_spi_buffer = function (block, 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 (block, 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 (block, 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 (block, 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 (block, 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 (block, 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 (block, 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 (block, 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 (block, 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 (block, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + name + ".reset()\n";
+    return code;
+}
+
+export const communicate_ow_read = function (block, 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 (block, 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 (block, 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;
+}
+
+export const communicate_ir_recv_init = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var bit = this.getFieldValue('type');
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (sub == "" && bit == "RC5") {
+        var code = "ir_rx = irremote.RC5_RX(" + pin + ")\n";
+    }else if (bit == "RC5"){
+        var code = "ir_rx = irremote.RC5_RX(" + pin + ", " + sub + ")\n";
+    }
+    else if (sub == "") {
+        var code = "ir_rx = irremote.NEC_RX(" + pin + ", " + bit + ")\n";
+    }
+    else {
+        var code = "ir_rx = irremote.NEC_RX(" + pin + ", " + bit + ", " + sub + ")\n";
+    }
+    return code;
+}
+
+export const internal_variable = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var index = this.getFieldValue('index');
+    var code = "ir_rx.code[" + index + "]";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const recv_fun = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var en = this.getFieldValue('en');
+    var code = "ir_rx.enable(" + en + ")\n";
+    return code;
+}
+
+export const ir_whether_recv = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var code = "ir_rx.any()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ir_recv_timeout = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ATOMIC);
+    var code = "ir_rx.timeout(" + time + ")\n";
+    return code;
+}
+
+export const communicate_ir_send_init = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var sam = this.getFieldValue('type');
+    var power = generator.valueToCode(this, 'power', generator.ORDER_ATOMIC);
+    if (sam == "RC5") {
+        var code = "ir_tx = irremote.RC5_TX(" + pin + ", " + power + ")\n";
+    }
+    else {
+        var code = "ir_tx = irremote.NEC_TX(" + pin + ", " + sam + ", " + power + ")\n";
+    }
+    return code;
+}
+
+export const ir_transmit_conventional_data = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var cmd = generator.valueToCode(this, 'cmd', generator.ORDER_ATOMIC);
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var toggle = generator.valueToCode(this, 'toggle', generator.ORDER_ATOMIC);
+    var code = "ir_tx.transmit(" + cmd + ", " + addr + ", " + toggle + ")\n";
+    return code;
+}
+
+export const ir_transmit_study_code = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var s_code = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var code = "ir_tx.transmit(pulses=" + s_code + ")\n";
+    return code;
+}
+
+export const ir_transmit_raw_code = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var raw = generator.valueToCode(this, 'raw', generator.ORDER_ATOMIC);
+    var code = "ir_tx.transmit(raw=" + raw + ")\n";
+    return code;
+}
+
+export const ir_transmit_busy = function (block, generator) {
+    generator.definitions_['import_irremote'] = 'import irremote';
+    var code = "ir_tx.busy()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_bluetooth_central_init = function (block, generator) {
+    generator.definitions_['import_ble_central'] = 'import ble_central';
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + " = ble_central.BLESimpleCentral()\n";
+    return code;
+}
+
+export const communicate_bluetooth_peripheral_init = function (block, generator) {
+    generator.definitions_['import_ble_peripheral'] = 'import ble_peripheral';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + " = ble_peripheral.BLESimplePeripheral(" + data + ")\n";
+    return code;
+}
+
+export const communicate_bluetooth_scan = function (block, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + ".scan()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_bluetooth_connect = function (block, generator) {
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var mode = this.getFieldValue('mode');
+    var code = name + ".connect(" + mode + '=' + data + ")\n";
+    return code;
+}
+
+export const communicate_bluetooth_disconnect = function (block, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + '.disconnect()\n';
+    return code;
+}
+
+export const communicate_bluetooth_mac = function (block, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return [name + ".mac", generator.ORDER_ATOMIC];
+}
+
+export const communicate_bluetooth_is_connected = function (block, generator) {
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + ".is_connected()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_bluetooth_send = function (block, generator) {
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + ".send(" + data + ")\n";
+    return code;
+}
+
+export const communicate_bluetooth_recv_only = function (block, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = v + '.recv()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const communicate_bluetooth_recv = function (block, generator) {
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var method = generator.valueToCode(this, 'METHOD', generator.ORDER_ATOMIC);
+    var code = v + '.recv(' + method + ')\n';
+    return code;
+}
+
+export const communicate_bluetooth_handle = function (block, generator) {
+    generator.definitions_['import_ble_handle'] = 'import ble_handle';
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var method = generator.valueToCode(this, 'METHOD', generator.ORDER_ATOMIC);
+    var code = v + '=ble_handle.Handle()\n' + v + '.recv(' + method + ')\n';
+    return code;
+}
+
+//espnow
+export const communicate_espnow_init = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var varName = generator.valueToCode(this, 'CHNL', generator.ORDER_ATOMIC);
+    var power = this.getFieldValue('op');
+    var code = "" + name + "=radio.ESPNow(channel=" + varName + ", txpower=" + power + ")\n";
+    return code;
+}
+
+export const communicate_espnow_init_new = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var varName = generator.valueToCode(this, 'CHNL', generator.ORDER_ATOMIC);
+    var varName2 = generator.valueToCode(this, 'DB', generator.ORDER_ATOMIC);
+    var code = "" + name + "=radio.ESPNow(channel=" + varName + ', txpower=' + varName2 + ")\n";
+    return code;
+}
+
+export const network_espnow_mac = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return [name + ".mac", generator.ORDER_ATOMIC];
+}
+
+export const network_espnow_info = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return [name + ".info()", generator.ORDER_ATOMIC];
+}
+
+export const network_espnow_recv = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var mode = this.getFieldValue('mode');
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + ".recv()" + mode;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_espnow_send = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var mac = generator.valueToCode(this, 'mac', generator.ORDER_ATOMIC);
+    var content = generator.valueToCode(this, 'content', generator.ORDER_ATOMIC);
+    var code = name + ".send(" + mac + ", " + content + ")\n";
+    return code;
+}
+
+export const network_espnow_recv_handle = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var method = generator.valueToCode(this, 'METHOD', generator.ORDER_ATOMIC);
+    var code = name + ".recv_cb(" + method + ")\n";
+    return code;
+}
+
+//radio
+export const espnow_radio_channel = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    generator.definitions_['var_declare_ESPNow_radio'] = "ESPNow_radio=radio.ESPNow()";
+    var varName = generator.valueToCode(this, 'CHNL', generator.ORDER_ATOMIC);
+    var code = "ESPNow_radio.set_channel(channel=" + varName + ")\n";
+    return code;
+}
+
+export const espnow_radio_txpower = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    generator.definitions_['var_declare_ESPNow_radio'] = "ESPNow_radio=radio.ESPNow()";
+    var power = this.getFieldValue('op');
+    var code = "ESPNow_radio.set_channel(txpower=" + power + ")\n";
+    return code;
+}
+
+export const espnow_radio_channel_new = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    var varName2 = generator.valueToCode(this, 'DB', generator.ORDER_ATOMIC);
+    generator.definitions_['var_declare_ESPNow_radio'] = "ESPNow_radio=radio.ESPNow(channel=1, txpower=" + varName2 + ")";
+    var varName = generator.valueToCode(this, 'CHNL', generator.ORDER_ATOMIC);
+    var code = "ESPNow_radio.set_channel(" + varName + ")\n";
+    return code;
+}
+
+export const espnow_radio_on_off = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    generator.definitions_['var_declare_ESPNow_radio'] = 'ESPNow_radio = radio.ESPNow()';
+    var op = this.getFieldValue('on_off');
+    var code = "ESPNow_radio.active(" + op + ")\n";
+    return code;
+}
+
+export const espnow_radio_send = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    generator.definitions_['var_declare_ESPNow_radio'] = 'ESPNow_radio = radio.ESPNow()';
+    var varName = generator.valueToCode(this, 'send', generator.ORDER_ATOMIC);
+    var code = 'ESPNow_radio.send("ffffffffffff",' + varName + ")\n";
+    return code;
+}
+
+export const espnow_radio_rec = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    generator.definitions_['var_declare_ESPNow_radio'] = 'ESPNow_radio = radio.ESPNow()';
+    var code = "ESPNow_radio.recv()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const espnow_radio_recv_msg = function (block, generator) {
+    var code = "ESPNow_radio_msg";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const espnow_radio_recv = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    generator.definitions_['import_ubinascii'] = 'import ubinascii';
+    generator.definitions_['var_declare_ESPNow_radio'] = 'ESPNow_radio = radio.ESPNow()';
+    var doCode = generator.statementToCode(block, 'DO') || generator.PASS;
+    generator.definitions_['def_ESPNow_radio_recv'] = 'def ESPNow_radio_recv(mac,ESPNow_radio_msg):\n' + doCode;
+    generator.definitions_['def_ESPNow_radio_recv_all'] = '_radio_msg_list = []\n'
+        + 'def ESPNow_radio_recv_callback(mac,ESPNow_radio_msg):\n'
+        + '    global _radio_msg_list\n'
+        + '    try:\n'
+        + '        ESPNow_radio_recv(mac,ESPNow_radio_msg)\n'
+        + '    except:\n'
+        + '        pass\n'
+        + '    if str(ESPNow_radio_msg) in _radio_msg_list:\n'
+        + "        eval('radio_recv_' + bytes.decode(ubinascii.hexlify(ESPNow_radio_msg)) + '()')\n";
+    generator.definitions_['ESPNow_radio_recv_callback'] = "ESPNow_radio.recv_cb(ESPNow_radio_recv_callback)\n";
+
+    return '';
+}
+
+var writeUTF = function (str, isGetBytes) {
+    var back = [];
+    var byteSize = 0;
+    for (var i = 0; i < str.length; i++) {
+        var code = str.charCodeAt(i);
+        if (0x00 <= code && code <= 0x7f) {
+            byteSize += 1;
+            back.push(code);
+        } else if (0x80 <= code && code <= 0x7ff) {
+            byteSize += 2;
+            back.push((192 | (31 & (code >> 6))));
+            back.push((128 | (63 & code)))
+        } else if ((0x800 <= code && code <= 0xd7ff) || (0xe000 <= code && code <= 0xffff)) {
+            byteSize += 3;
+            back.push((224 | (15 & (code >> 12))));
+            back.push((128 | (63 & (code >> 6))));
+            back.push((128 | (63 & code)))
+        }
+    }
+    for (i = 0; i < back.length; i++) {
+        back[i] &= 0xff;
+    }
+    if (isGetBytes) {
+        return back;
+    }
+    if (byteSize <= 0xff) {
+        return [0, byteSize].concat(back);
+    }
+    return [byteSize >> 8, byteSize & 0xff].concat(back);
+}
+
+var toUTF8Hex = function (str) {
+    var charBuf = writeUTF(str, true);
+    var re = '';
+    for (var i = 0; i < charBuf.length; i++) {
+        var x = (charBuf[i] & 0xFF).toString(16);
+        if (x.length === 1) {
+            x = '0' + x;
+        }
+        re += x;
+    }
+    return re;
+}
+
+export const espnow_radio_recv_certain_msg = function (block, generator) {
+    generator.definitions_['import_radio'] = "import radio";
+    generator.definitions_['import_ubinascii'] = 'import ubinascii';
+    generator.definitions_['var_declare_ESPNow_radio'] = 'ESPNow_radio = radio.ESPNow()';
+    var doCode = generator.statementToCode(block, 'DO') || generator.PASS;
+    generator.definitions_['def_ESPNow_radio_recv_all'] = '_radio_msg_list = []\n'
+        + 'def ESPNow_radio_recv_callback(mac,ESPNow_radio_msg):\n'
+        + '    global _radio_msg_list\n'
+        + '    try:\n'
+        + '        ESPNow_radio_recv(mac,ESPNow_radio_msg)\n'
+        + '    except:\n'
+        + '        pass\n'
+        + '    if str(ESPNow_radio_msg) in _radio_msg_list:\n'
+        + "        eval('radio_recv_' + bytes.decode(ubinascii.hexlify(ESPNow_radio_msg)) + '()')\n";
+    generator.definitions_['ESPNow_radio_recv_callback'] = "ESPNow_radio.recv_cb(ESPNow_radio_recv_callback)\n";
+    var message = block.getFieldValue('msg');
+    var message_utf8 = toUTF8Hex(message);
+    generator.definitions_['def_radio_recv_' + message_utf8] =
+        '_radio_msg_list.append(\'' + message + '\')\n' +
+        'def radio_recv_' + message_utf8 + '():\n' + doCode;
+    return '';
+}
+
+export const espnow_radio_recv_new = function (block, generator) {
+    generator.definitions_['import_radio'] = 'import radio';
+    generator.definitions_['var_declare_ESPNow_radio'] = 'ESPNow_radio = radio.ESPNow()';
+    var doCode = generator.statementToCode(block, 'DO') || generator.PASS;
+    generator.definitions_['def_ESPNow_radio_recv'] = 'def ESPNow_radio_recv(mac, ESPNow_radio_msg):\n'
+        + `${doCode}\nESPNow_radio.recv_cb("__all__", ESPNow_radio_recv)\n`;
+    return '';
+}
+
+export const espnow_radio_recv_certain_msg_new = function (block, generator) {
+    generator.definitions_['import_radio'] = 'import radio';
+    generator.definitions_['var_declare_ESPNow_radio'] = 'ESPNow_radio = radio.ESPNow()';
+    var doCode = generator.statementToCode(block, 'DO') || generator.PASS;
+    var message = block.getFieldValue('msg');
+    generator.definitions_['def_ESPNow_radio_recv_' + message] = 'def ESPNow_radio_recv(mac, ESPNow_radio_msg):\n'
+        + `${doCode}\nESPNow_radio.recv_cb("${message}", ESPNow_radio_recv)\n`;
+    return '';
+}
+
+export const lora_init = function (block, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var sv = generator.valueToCode(this, 'SPISUB', generator.ORDER_ATOMIC);
+    var pv = generator.valueToCode(this, 'PINSUB', generator.ORDER_ATOMIC);
+    var fr = generator.valueToCode(this, 'frequency', generator.ORDER_ATOMIC);
+    var r = generator.valueToCode(this, 'rate', generator.ORDER_ATOMIC);
+    var f = generator.valueToCode(this, 'factor', generator.ORDER_ATOMIC);
+    var p = generator.valueToCode(this, 'power', generator.ORDER_ATOMIC);
+    var bandwidth = this.getFieldValue('bandwidth');
+    var code;
+    generator.definitions_['import_rfm98'] = 'import rfm98';
+    var code = v + ' = rfm98.RFM98(' + sv + ', cs_pin=' + pv + ', frequency_mhz=' + fr + ', signal_bandwidth=' + bandwidth + ', coding_rate=' + r + ', spreading_factor=' + f + ', tx_power=' + p + ')\n';
+    return code;
+}
+
+export const lora_packet = function (block, generator) {
+    generator.definitions_['import_rfm98'] = 'import rfm98';
+    var key = this.getFieldValue('key');
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return [name + "." + key + '()', generator.ORDER_ATOMIC];
+}
+
+export const lora_send = function (block, generator) {
+    generator.definitions_['import_rfm98'] = 'import rfm98';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = name + ".send(" + data + ")\n";
+    return code;
+}
+
+export const lora_recv = function (block, generator) {
+    generator.definitions_['import_rfm98'] = 'import rfm98';
+    var name = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return [name + '.recv()', generator.ORDER_ATOMIC];
+}
+
+export const urequests_get = function (block, generator) {
+    generator.definitions_.import_requests = "import urequests";
+    var varName = generator.variableDB_.getName(this.getFieldValue('VAR'), Blockly.Variables.NAME_TYPE);
+    var str = generator.valueToCode(this, 'DOMAIN', generator.ORDER_ATOMIC);
+    var code = varName + '= ' + 'urequests.get(' + str + ')\n';
+    return code;
+}
+
+export const urequests_attribute = function (block, generator) {
+    generator.definitions_.import_requests = "import urequests";
+    var varName = generator.valueToCode(this, 'VAL', generator.ORDER_ASSIGNMENT) || '0';
+    var attr = this.getFieldValue('ATTR');
+    var code = varName + "." + attr;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const urequests_method = function (block, generator) {
+    generator.definitions_.import_requests = "import urequests";
+    var method = this.getFieldValue('DIR');
+    var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "urequests." + method + "(" + str + ')';
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/control.js

@@ -0,0 +1,119 @@
+import * as Blockly from 'blockly/core';
+import { controls_repeat_ext } from '@mixly/python/generators/control';
+
+export const base_setup = function (_, generator) {
+    var branch = generator.statementToCode(this, 'DO');
+    branch = branch.replace(/(^\s*)|(\s*$)/g, "").replace(/\n {4}/g, '\n');//去除两端空格
+    if (branch) {
+        if (branch.endsWith('\n')) {
+            generator.setups_['setup_setup'] = branch;
+        } else {
+            generator.setups_['setup_setup'] = branch + '\n';
+        }
+    }
+    return '';
+}
+
+// ok
+export const controls_if = function (a, generator) {
+    var b = 0,
+        c = "",
+        d,
+        e;
+    do
+        e = generator.valueToCode(a, "IF" + b, generator.ORDER_NONE) || "False", d = generator.statementToCode(a, "DO" + b) || generator.PASS, c += (0 == b ? "if " : "elif ") + e + ":\n" + d, ++b;
+    while (a.getInput("IF" + b));
+    a.getInput("ELSE") && (d = generator.statementToCode(a, "ELSE") || generator.PASS, c += "else:\n" + d);
+    return c
+}
+
+// ok
+export const controls_for = function (a, generator) {
+    var b = generator.variableDB_.getName(a.getFieldValue("VAR"), Blockly.Variables.NAME_TYPE),
+        //var b = generator.valueToCode(a, "VAR", generator.ORDER_MEMBER) || "''",
+        c = generator.valueToCode(a, "FROM", generator.ORDER_NONE) || "0",
+        d = generator.valueToCode(a, "TO", generator.ORDER_NONE) || "0",
+        e = generator.valueToCode(a, "STEP", generator.ORDER_NONE) || "1",
+        f = generator.addLoopTrap(generator.statementToCode(a, "DO"), a.id) || generator.PASS,
+        g = "",
+        h = function (_, generator) {
+            return generator.provideFunction_("upRange",
+                ["def " + generator.FUNCTION_NAME_PLACEHOLDER_ + "(start, stop, step):", "  while start <= stop:", "    yield start", "    start += abs(step)"])
+        },
+        k = function (_, generator) {
+            return generator.provideFunction_("downRange", ["def " + generator.FUNCTION_NAME_PLACEHOLDER_ + "(start, stop, step):", "  while start >= stop:", "    yield start", "    start -= abs(step)"])
+        }
+    a = function (a, b, c) {
+        return "(" + a + " <= " + b + ") and " + h() + "(" + a + ", " + b + ", " + c + ") or " + k() + "(" + a + ", " + b + ", " + c + ")"
+    }
+    if (Blockly.isNumber(c) && Blockly.isNumber(d) &&
+        Blockly.isNumber(e))
+        c = parseFloat(c), d = parseFloat(d), e = Math.abs(parseFloat(e)), 0 === c % 1 && 0 === d % 1 && 0 === e % 1 ? (c <= d ? (d++, a = 0 == c && 1 == e ? d : c + ", " + d, 1 != e && (a += ", " + e)) : (d--, a = c + ", " + d + ", -" + e), a = "range(" + a + ")") : (a = c < d ? h() : k(), a += "(" + c + ", " + d + ", " + e + ")");
+    else {
+        var l = function (a, c) {
+            if (Blockly.isNumber(a))
+                a = parseFloat(a);
+            else {
+                var d = generator.variableDB_.getDistinctName(b + c, Blockly.Variables.NAME_TYPE);
+                g += d + " = " + a + "\n";
+                a = d
+            }
+            return a
+        }
+        c = l(c, "_start");
+        d = l(d, "_end");
+        l(e, "_inc");
+        a = "number" == typeof c && "number" == typeof d ? c < d ? h(c, d, e) : k(c, d, e) : a(c, d, e)
+    }
+    return g += "for " + b + " in " + a + ":\n" + f
+}
+
+// ok
+export const controls_repeat = controls_repeat_ext;
+
+export const controls_whileUntil = function (a, generator) {
+    var b = "UNTIL" == a.getFieldValue("MODE"),
+        c = generator.valueToCode(a, "BOOL", b ? generator.ORDER_LOGICAL_NOT : generator.ORDER_NONE) || "False",
+        d = generator.addLoopTrap(generator.statementToCode(a, "DO"), a.id) || generator.PASS;
+    b && (c = "not " + c);
+    return "while " + c + ":\n" + d
+}
+
+// ok
+export const controls_flow_statements = function (a) {
+    switch (a.getFieldValue("FLOW")) {
+        case "BREAK":
+            return "break\n";
+        case "CONTINUE":
+            return "continue\n"
+    }
+    throw "Unknown flow statement.";
+}
+
+//ok
+export const controls_forEach = function (block, generator) {
+    // For each loop.
+    var variable0 = generator.variableDB_.getName(
+        block.getFieldValue('VAR'), Blockly.Variables.NAME_TYPE);
+    var argument0 = generator.valueToCode(block, 'LIST',
+        generator.ORDER_RELATIONAL) || '[]';
+    var branch = generator.statementToCode(block, 'DO');
+    branch = generator.addLoopTrap(branch, block.id) ||
+        generator.PASS;
+    var code = 'for ' + variable0 + ' in ' + argument0 + ':\n' + branch;
+    return code;
+}
+
+// ok
+export const controls_type = function (_, generator) {
+    var data = generator.valueToCode(this, 'DATA', generator.ORDER_ATOMIC) || '1000'
+    var code = 'type(' + data + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const controls_typeLists = function (_, generator) {
+    generator.definitions_['import_microbit_*'] = 'from microbit import *';
+    var type = this.getFieldValue('type');
+    // generator.definitions_['func_type' + type] = code;
+    return [type, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/display.js

@@ -0,0 +1,496 @@
+export const display_show_image_or_string = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = "matrix.show(" + data + ")\n";
+    return code;
+}
+
+export const display_scroll_string = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = "matrix.scroll(" + data + ")\n";
+    return code;
+}
+
+export const display_show_static = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = "matrix.showstatic(" + data + ")\n";
+    return code;
+}
+
+export const display_show_image_or_string_delay = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var code = "matrix.show(" + data + ', ' + time + ")\n";
+    return code;
+}
+
+export const display_scroll_string_delay = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var code = "matrix.scroll(" + data + ', ' + time + ")\n";
+    return code;
+}
+
+export const display_image_create = function (block, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var colours = {
+        "#000000": "0",
+        //"#440000": "1",
+        //"#660000": "2",
+        //"#880000": "3",
+        //"#aa0000": "4",
+        //"#bb0000": "5",
+        //"#cc0000": "6",
+        //"#dd0000": "7",
+        //"#ee0000": "8",
+        "#ff0000": "1"
+    }
+    var colour_00 = colours[block.getFieldValue("00")];
+    var colour_01 = colours[block.getFieldValue("01")];
+    var colour_02 = colours[block.getFieldValue("02")];
+    var colour_03 = colours[block.getFieldValue("03")];
+    var colour_04 = colours[block.getFieldValue("04")];
+    var colour_05 = colours[block.getFieldValue("05")];
+    var colour_06 = colours[block.getFieldValue("06")];
+    var colour_07 = colours[block.getFieldValue("07")];
+    var colour_08 = colours[block.getFieldValue("08")];
+    var colour_09 = colours[block.getFieldValue("09")];
+    var colour_0a = colours[block.getFieldValue("0a")];
+    var colour_0b = colours[block.getFieldValue("0b")];
+    var colour_0c = colours[block.getFieldValue("0c")];
+    var colour_0d = colours[block.getFieldValue("0d")];
+    var colour_0e = colours[block.getFieldValue("0e")];
+    var colour_0f = colours[block.getFieldValue("0f")];
+    var colour_10 = colours[block.getFieldValue("10")];
+    var colour_11 = colours[block.getFieldValue("11")];
+    var colour_12 = colours[block.getFieldValue("12")];
+    var colour_13 = colours[block.getFieldValue("13")];
+    var colour_14 = colours[block.getFieldValue("14")];
+    var colour_15 = colours[block.getFieldValue("15")];
+    var colour_16 = colours[block.getFieldValue("16")];
+    var colour_17 = colours[block.getFieldValue("17")];
+    var colour_18 = colours[block.getFieldValue("18")];
+    var colour_19 = colours[block.getFieldValue("19")];
+    var colour_1a = colours[block.getFieldValue("1a")];
+    var colour_1b = colours[block.getFieldValue("1b")];
+    var colour_1c = colours[block.getFieldValue("1c")];
+    var colour_1d = colours[block.getFieldValue("1d")];
+    var colour_1e = colours[block.getFieldValue("1e")];
+    var colour_1f = colours[block.getFieldValue("1f")];
+    var colour_20 = colours[block.getFieldValue("20")];
+    var colour_21 = colours[block.getFieldValue("21")];
+    var colour_22 = colours[block.getFieldValue("22")];
+    var colour_23 = colours[block.getFieldValue("23")];
+    var colour_24 = colours[block.getFieldValue("24")];
+    var colour_25 = colours[block.getFieldValue("25")];
+    var colour_26 = colours[block.getFieldValue("26")];
+    var colour_27 = colours[block.getFieldValue("27")];
+    var colour_28 = colours[block.getFieldValue("28")];
+    var colour_29 = colours[block.getFieldValue("29")];
+    var colour_2a = colours[block.getFieldValue("2a")];
+    var colour_2b = colours[block.getFieldValue("2b")];
+    var colour_2c = colours[block.getFieldValue("2c")];
+    var colour_2d = colours[block.getFieldValue("2d")];
+    var colour_2e = colours[block.getFieldValue("2e")];
+    var colour_2f = colours[block.getFieldValue("2f")];
+    var colour_30 = colours[block.getFieldValue("30")];
+    var colour_31 = colours[block.getFieldValue("31")];
+    var colour_32 = colours[block.getFieldValue("32")];
+    var colour_33 = colours[block.getFieldValue("33")];
+    var colour_34 = colours[block.getFieldValue("34")];
+    var colour_35 = colours[block.getFieldValue("35")];
+    var colour_36 = colours[block.getFieldValue("36")];
+    var colour_37 = colours[block.getFieldValue("37")];
+    var colour_38 = colours[block.getFieldValue("38")];
+    var colour_39 = colours[block.getFieldValue("39")];
+    var colour_3a = colours[block.getFieldValue("3a")];
+    var colour_3b = colours[block.getFieldValue("3b")];
+    var colour_3c = colours[block.getFieldValue("3c")];
+    var colour_3d = colours[block.getFieldValue("3d")];
+    var colour_3e = colours[block.getFieldValue("3e")];
+    var colour_3f = colours[block.getFieldValue("3f")];
+    var colour_40 = colours[block.getFieldValue("40")];
+    var colour_41 = colours[block.getFieldValue("41")];
+    var colour_42 = colours[block.getFieldValue("42")];
+    var colour_43 = colours[block.getFieldValue("43")];
+    var colour_44 = colours[block.getFieldValue("44")];
+    var colour_45 = colours[block.getFieldValue("45")];
+    var colour_46 = colours[block.getFieldValue("46")];
+    var colour_47 = colours[block.getFieldValue("47")];
+    var colour_48 = colours[block.getFieldValue("48")];
+    var colour_49 = colours[block.getFieldValue("49")];
+    var colour_4a = colours[block.getFieldValue("4a")];
+    var colour_4b = colours[block.getFieldValue("4b")];
+    var colour_4c = colours[block.getFieldValue("4c")];
+    var colour_4d = colours[block.getFieldValue("4d")];
+    var colour_4e = colours[block.getFieldValue("4e")];
+    var colour_4f = colours[block.getFieldValue("4f")];
+    var colour_50 = colours[block.getFieldValue("50")];
+    var colour_51 = colours[block.getFieldValue("51")];
+    var colour_52 = colours[block.getFieldValue("52")];
+    var colour_53 = colours[block.getFieldValue("53")];
+    var colour_54 = colours[block.getFieldValue("54")];
+    var colour_55 = colours[block.getFieldValue("55")];
+    var colour_56 = colours[block.getFieldValue("56")];
+    var colour_57 = colours[block.getFieldValue("57")];
+    var colour_58 = colours[block.getFieldValue("58")];
+    var colour_59 = colours[block.getFieldValue("59")];
+    var colour_5a = colours[block.getFieldValue("5a")];
+    var colour_5b = colours[block.getFieldValue("5b")];
+    var colour_5c = colours[block.getFieldValue("5c")];
+    var colour_5d = colours[block.getFieldValue("5d")];
+    var colour_5e = colours[block.getFieldValue("5e")];
+    var colour_5f = colours[block.getFieldValue("5f")];
+    var colour_60 = colours[block.getFieldValue("60")];
+    var colour_61 = colours[block.getFieldValue("61")];
+    var colour_62 = colours[block.getFieldValue("62")];
+    var colour_63 = colours[block.getFieldValue("63")];
+    var colour_64 = colours[block.getFieldValue("64")];
+    var colour_65 = colours[block.getFieldValue("65")];
+    var colour_66 = colours[block.getFieldValue("66")];
+    var colour_67 = colours[block.getFieldValue("67")];
+    var colour_68 = colours[block.getFieldValue("68")];
+    var colour_69 = colours[block.getFieldValue("69")];
+    var colour_6a = colours[block.getFieldValue("6a")];
+    var colour_6b = colours[block.getFieldValue("6b")];
+    var colour_6c = colours[block.getFieldValue("6c")];
+    var colour_6d = colours[block.getFieldValue("6d")];
+    var colour_6e = colours[block.getFieldValue("6e")];
+    var colour_6f = colours[block.getFieldValue("6f")];
+    var colour_70 = colours[block.getFieldValue("70")];
+    var colour_71 = colours[block.getFieldValue("71")];
+    var colour_72 = colours[block.getFieldValue("72")];
+    var colour_73 = colours[block.getFieldValue("73")];
+    var colour_74 = colours[block.getFieldValue("74")];
+    var colour_75 = colours[block.getFieldValue("75")];
+    var colour_76 = colours[block.getFieldValue("76")];
+    var colour_77 = colours[block.getFieldValue("77")];
+    var colour_78 = colours[block.getFieldValue("78")];
+    var colour_79 = colours[block.getFieldValue("79")];
+    var colour_7a = colours[block.getFieldValue("7a")];
+    var colour_7b = colours[block.getFieldValue("7b")];
+    var colour_7c = colours[block.getFieldValue("7c")];
+    var colour_7d = colours[block.getFieldValue("7d")];
+    var colour_7e = colours[block.getFieldValue("7e")];
+    var colour_7f = colours[block.getFieldValue("7f")];
+    var code = 'matrix.Image("' + colour_00 + colour_01 + colour_02 + colour_03 + colour_04 + colour_05 + colour_06 + colour_07 + colour_08 + colour_09 + colour_0a + colour_0b + colour_0c + colour_0d + colour_0e + colour_0f + ':' + colour_10 + colour_11 + colour_12 + colour_13 + colour_14 + colour_15 + colour_16 + colour_17 + colour_18 + colour_19 + colour_1a + colour_1b + colour_1c + colour_1d + colour_1e + colour_1f + ':' + colour_20 + colour_21 + colour_22 + colour_23 + colour_24 + colour_25 + colour_26 + colour_27 + colour_28 + colour_29 + colour_2a + colour_2b + colour_2c + colour_2d + colour_2e + colour_2f + ':' + colour_30 + colour_31 + colour_32 + colour_33 + colour_34 + colour_35 + colour_36 + colour_37 + colour_38 + colour_39 + colour_3a + colour_3b + colour_3c + colour_3d + colour_3e + colour_3f + ':' + colour_40 + colour_41 + colour_42 + colour_43 + colour_44 + colour_45 + colour_46 + colour_47 + colour_48 + colour_49 + colour_4a + colour_4b + colour_4c + colour_4d + colour_4e + colour_4f + ':' + colour_50 + colour_51 + colour_52 + colour_53 + colour_54 + colour_55 + colour_56 + colour_57 + colour_58 + colour_59 + colour_5a + colour_5b + colour_5c + colour_5d + colour_5e + colour_5f + ':' + colour_60 + colour_61 + colour_62 + colour_63 + colour_64 + colour_65 + colour_66 + colour_67 + colour_68 + colour_69 + colour_6a + colour_6b + colour_6c + colour_6d + colour_6e + colour_6f + ':' + colour_70 + colour_71 + colour_72 + colour_73 + colour_74 + colour_75 + colour_76 + colour_77 + colour_78 + colour_79 + colour_7a + colour_7b + colour_7c + colour_7d + colour_7e + colour_7f + '")';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_image_builtins = function (block, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var dropdown_image = block.getFieldValue('image');
+    var code = 'matrix.Image.' + dropdown_image;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_get_pixel = function (block, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var value_x = generator.valueToCode(block, 'x', generator.ORDER_ATOMIC);
+    var value_y = generator.valueToCode(block, 'y', generator.ORDER_ATOMIC);
+    var code = 'matrix.get_pixel(int(' + value_x + '), int(' + value_y + '))';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_bright_point = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var dropdown_stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = 'matrix.set_pixel(int(' + x + '), int(' + y + '), ' + dropdown_stat + ")\n";
+    return code;
+}
+
+export const display_get_screen_pixel = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var code = 'matrix.get_brightness()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_get_screen_image = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var code = 'matrix.get_screenimage()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_bright_screen = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var code = 'matrix.set_brightness(' + x + ')\n';
+    return code;
+}
+
+export const display_blink_rate = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var code = 'matrix.blink_rate(' + x + ')\n';
+    return code;
+}
+
+export const display_clear = function (_, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var code = 'matrix.clear()\n';
+    return code;
+}
+
+export const display_use_i2c_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var i2csub = generator.valueToCode(this, 'I2CSUB', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var row = generator.valueToCode(this, 'row', generator.ORDER_ATOMIC);
+    var column = generator.valueToCode(this, 'column', generator.ORDER_ATOMIC);
+    var code = sub + " = ssd1306.SSD1306_I2C(" + row + ", " + column + ", " + i2csub + ")\n";
+    return code;
+}
+
+export const display_draw_4strings = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var value_text_line1 = generator.valueToCode(this, 'Text_line1', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var value_text_line2 = generator.valueToCode(this, 'Text_line2', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var value_text_line3 = generator.valueToCode(this, 'Text_line3', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var value_text_line4 = generator.valueToCode(this, 'Text_line4', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var code = varName + '.show_str(' + value_text_line1 + ', ' + value_text_line2 + ', ' + value_text_line3 + ', ' + value_text_line4 + ')\n'
+    return code;
+}
+
+export const display_line_arbitrarily = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x1 = generator.valueToCode(this, 'x1', generator.ORDER_ATOMIC);
+    var location_y1 = generator.valueToCode(this, 'y1', generator.ORDER_ATOMIC);
+    var location_x2 = generator.valueToCode(this, 'x2', generator.ORDER_ATOMIC);
+    var location_y2 = generator.valueToCode(this, 'y2', generator.ORDER_ATOMIC);
+    var code = varName + '.show_line(' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', 1)\n';
+    return code;
+}
+
+export const display_rect = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var value_width = generator.valueToCode(this, 'width', generator.ORDER_ATOMIC);
+    var value_height = generator.valueToCode(this, 'height', generator.ORDER_ATOMIC);
+    var checkbox_fill = this.getFieldValue("fill") == 'TRUE' ? 'True' : 'False';
+    var size = this.getFieldValue('OP');
+    var code = '';
+    switch (checkbox_fill) {
+        case "True":
+            code = varName + '.show_fill_rect(' + location_x + ', ' + location_y + ', ' + value_width + ', ' + value_height + ', ' + size + ')\n';
+            break;
+        case "False":
+            code = varName + '.show_rect(' + location_x + ', ' + location_y + ', ' + value_width + ', ' + value_height + ', ' + size + ')\n';
+            break;
+    }
+    return code;
+}
+
+export const image_arithmetic = function (block, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var op = block.getFieldValue("OP");
+    var imga = generator.valueToCode(block, 'A', generator.ORDER_ATOMIC);
+    var imgb = generator.valueToCode(block, 'B', generator.ORDER_ATOMIC);
+    var code = '';
+    if (op == 'INTERSECTION') {
+        code = imga + '-(' + imga + '-' + imgb + ')';
+    } else {
+        code = imga + op + imgb;
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_line = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var value_length = generator.valueToCode(this, 'length', generator.ORDER_ATOMIC);
+    var value_direction = this.getFieldValue("direction");
+    var code = varName + '.show_' + value_direction + '(' + location_x + ', ' + location_y + ', ' + value_length + ', 1)\n';
+    return code;
+}
+
+export const display_onoff = function (_, generator) {
+    var code = (this.getFieldValue('ONOFF') == 'ON') ? '1' : '0';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_shift = function (block, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var op = block.getFieldValue("OP");
+    var image = generator.valueToCode(block, 'img', generator.ORDER_ATOMIC);
+    var value = generator.valueToCode(block, 'val', generator.ORDER_ATOMIC);
+    var code = image + '.shift_' + op + '(' + value + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_fill = function (_, generator) {
+    var varName = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    generator.definitions_['import_machine'] = 'import machine';
+    var key = this.getFieldValue('key');
+    var code = varName + '.show_fill(' + key + ')\n';
+    return code;
+}
+
+// export const switch = function (_, generator) {
+//     var code = this.getFieldValue('flag');
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+export const display_tm_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 == 'TM1650') {
+        generator.definitions_['import_tm1650'] = 'import tm1650';
+        code = v + ' = tm1650.' + key + "(" + iv + ')\n';
+    } else if (key == 'TM1637') {
+        generator.definitions_['import_tm1637'] = 'import tm1637';
+        code = v + ' = tm1637.' + key + "(" + iv + ')\n';
+    }
+    return code;
+}
+
+export const display_tm1650_power = function (_, generator) {
+    var type = this.getFieldValue("TYPE");
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var stat = this.getFieldValue("STAT");
+    var code = v + '.' + type + stat + "()\n";
+    return code;
+}
+
+export const display_tm1650_show_num = function (_, generator) {
+    var type = this.getFieldValue("TYPE");
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var val = generator.valueToCode(this, 'VALUE', generator.ORDER_ATOMIC);
+    var code = v + '.' + type + "_show_num(" + val + ")\n";
+    return code;
+}
+
+export const display_tm1650_show_dot = function (_, generator) {
+    var type = this.getFieldValue("TYPE");
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var n = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    var stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = v + '.' + type + "_show_dot(" + n + ", " + stat + ")\n";
+    return code;
+}
+
+export const display_animate = function (_, generator) {
+    // Boolean values true and false.
+    var name = this.getFieldValue("ANIMATION");
+    var code = 'matrix.Image.' + name;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_circle = function (_, generator) {
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var location_x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var value_r = generator.valueToCode(this, 'r', generator.ORDER_ATOMIC);
+    var checkbox_fill = this.getFieldValue("fill") == 'TRUE' ? 'True' : 'False';
+    var size = this.getFieldValue('OP');
+    var code = '';
+    switch (checkbox_fill) {
+        case "True":
+            code = varName + '.show_fill_circle(' + location_x + ', ' + location_y + ', ' + value_r + ', ' + size + ')\n';
+            break;
+        case "False":
+            code = varName + '.show_circle(' + location_x + ', ' + location_y + ', ' + value_r + ', ' + size + ')\n';
+            break;
+    }
+    return code;
+}
+
+export const display_triangle = function (_, generator) {
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var location_x0 = generator.valueToCode(this, 'x0', generator.ORDER_ATOMIC);
+    var location_y0 = generator.valueToCode(this, 'y0', generator.ORDER_ATOMIC);
+    var location_x1 = generator.valueToCode(this, 'x1', generator.ORDER_ATOMIC);
+    var location_y1 = generator.valueToCode(this, 'y1', generator.ORDER_ATOMIC);
+    var location_x2 = generator.valueToCode(this, 'x2', generator.ORDER_ATOMIC);
+    var location_y2 = generator.valueToCode(this, 'y2', generator.ORDER_ATOMIC);
+    var checkbox_fill = this.getFieldValue("fill") == 'TRUE' ? 'True' : 'False';
+    var size = this.getFieldValue('OP');
+    var code = '';
+    switch (checkbox_fill) {
+        case "True":
+            code = varName + '.show_fill_triangle(' + location_x0 + ', ' + location_y0 + ', ' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', ' + size + ')\n';
+            break;
+        case "False":
+            code = varName + '.show_triangle(' + location_x0 + ', ' + location_y0 + ', ' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', ' + size + ')\n';
+            break;
+    }
+    return code;
+}
+
+export const display_oled_showBitmap = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'START_X', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'START_Y', generator.ORDER_ATOMIC);
+    var bmp = generator.valueToCode(this, 'bitmap_name', generator.ORDER_ATOMIC);
+    var w = generator.valueToCode(this, 'WIDTH', generator.ORDER_ATOMIC);
+    var h = generator.valueToCode(this, 'HEIGHT', generator.ORDER_ATOMIC);
+    var code = varName + '.show_bitmap(' + location_x + ', ' + location_y + ', ' + bmp + ', ' + w + ', ' + h + ')\n';
+    return code;
+}
+
+export const display_oled_drawPixel = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'POS_X', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'POS_Y', generator.ORDER_ATOMIC);
+    var code = varName + '.show_pixel(' + location_x + ', ' + location_y + ')\n';
+    return code;
+}
+
+// pe:
+export const display_matrix_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 == '32x12 Matrix') {
+        generator.definitions_['import_matrix32x12'] = 'import matrix32x12';
+        code = v + ' = matrix32x12.Matrix(' + iv + ')\n';
+    } else if (key == 'TM1637') {
+        generator.definitions_['import_tm1637'] = 'import tm1637';
+        code = v + ' = tm1637.' + key + "(" + iv + ')\n';
+    }
+    return code;
+}
+
+export const display_show_image = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    generator.definitions_['import_matrix32x12'] = 'import matrix32x12';
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".set_buffer(" + data + ")\n";
+    return code;
+}
+
+export const display_scroll_string_extern = function (_, generator) {
+    generator.definitions_['import_matrix32x12'] = 'import matrix32x12';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".scroll(" + data + ")\n";
+    return code;
+}

mixly/boards/default_src/micropython/generators/display_extern.js

@@ -0,0 +1,726 @@
+import { Boards } from 'mixly';
+
+export const display_matrix_use_i2c_init = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var iv = generator.valueToCode(this, 'I2CSUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue("key");
+    var font = '';
+    if (['mpython', 'mixgo_pe', 'mixgo_nova'].indexOf(version) >= 0) {
+        font = '0x700000'
+    } else if (['mixgo_sant'].indexOf(version) >= 0) {
+        font = '0xE00000'
+    } else {
+        font = '0x3A0000'
+    }
+    var code;
+    if (key == '32x12 Matrix') {
+        generator.definitions_['import_matrix32x12'] = 'import matrix32x12';
+        code = v + ' = matrix32x12.Matrix(' + iv + ', font_address=' + font + ')\n';
+    } else if (key == '16x8 Matrix') {
+        generator.definitions_['import_matrix16x8'] = 'import matrix16x8';
+        code = v + ' = matrix16x8.Matrix(' + iv + ')\n';
+    }
+    return code;
+}
+
+export const display_matrix_extern_show_image = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".shows(" + data + ")\n";
+    return code;
+}
+
+export const display_matrix_extern_show_image_or_string_delay = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var space = generator.valueToCode(this, 'space', generator.ORDER_ASSIGNMENT);
+    var op = this.getFieldValue('center');
+    var code = v + ".shows(" + data + ', space=' + space + ', center=' + op + ")\n";
+    return code;
+}
+
+export const display_matrix_extern_show_frame_string = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".frame(" + data + ")\n";
+    return code;
+}
+
+export const display_matrix_extern_show_frame_string_delay = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var code = v + ".frame(" + data + ', delay=' + time + ")\n";
+    return code;
+}
+
+export const display_matrix_extern_scroll_string = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".scroll(" + data + ")\n";
+    return code;
+}
+
+export const display_matrix_extern_scroll_string_delay = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var space = generator.valueToCode(this, 'space', generator.ORDER_ASSIGNMENT);
+    var code = v + ".scroll(" + data + ', speed=' + time + ', space=' + space + ")\n";
+    return code;
+}
+
+export const display_matrix_extern_clear = function (block, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.fill(0)\n' + v + '.show()\n';
+    return code;
+}
+
+export const display_matrix_extern_shift = function (a, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var op = a.getFieldValue("OP");
+    var value = generator.valueToCode(a, 'val', generator.ORDER_ATOMIC);
+    var code = v + '.' + op + '(' + value + ')\n';
+    return code;
+}
+
+export const display_matrix_extern_get_pixel = function (block, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var value_x = generator.valueToCode(block, 'x', generator.ORDER_ATOMIC);
+    var value_y = generator.valueToCode(block, 'y', generator.ORDER_ATOMIC);
+    var code = v + '.pixel(int(' + value_x + '), int(' + value_y + '))';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_matrix_extern_bright_point = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var dropdown_stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = v + '.pixel(int(' + x + '), int(' + y + '), ' + dropdown_stat + ")\n" + v + '.show()\n';
+    return code;
+}
+
+export const display_matrix_extern_get_screen_pixel = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.get_brightness()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_matrix_extern_bright_screen = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var code = v + '.set_brightness(' + x + ')\n';
+    return code;
+}
+
+export const display_matrix_extern_image_builtins = function (block, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var dropdown_image = block.getFieldValue('image');
+    var code = v + '.' + dropdown_image;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const matrix_extern_image_arithmetic = function (a, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var op = a.getFieldValue("OP");
+    var imga = generator.valueToCode(a, 'A', generator.ORDER_ATOMIC);
+    var imgb = generator.valueToCode(a, 'B', generator.ORDER_ATOMIC);
+    var code = v + '.map_' + op + '(' + imga + ', ' + imgb + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const matrix_extern_image_invert = function (a, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var imga = generator.valueToCode(a, 'A', generator.ORDER_ATOMIC);
+    var code = v + '.map_invert(' + imga + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//oled
+export const display_use_i2c_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var i2csub = generator.valueToCode(this, 'I2CSUB', generator.ORDER_ATOMIC);
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var row = generator.valueToCode(this, 'row', generator.ORDER_ATOMIC);
+    var column = generator.valueToCode(this, 'column', generator.ORDER_ATOMIC);
+    var code = sub + " = ssd1306.SSD1306_I2C(" + row + ", " + column + ", " + i2csub + ")\n";
+    return code;
+}
+
+export const display_draw_4strings = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var value_text_line1 = generator.valueToCode(this, 'Text_line1', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var value_text_line2 = generator.valueToCode(this, 'Text_line2', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var value_text_line3 = generator.valueToCode(this, 'Text_line3', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var value_text_line4 = generator.valueToCode(this, 'Text_line4', generator.ORDER_ASSIGNMENT) || '\'\'';
+    var code = varName + '.show_str(' + value_text_line1 + ', ' + value_text_line2 + ', ' + value_text_line3 + ', ' + value_text_line4 + ')\n'
+    return code;
+}
+
+export const display_line_arbitrarily = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x1 = generator.valueToCode(this, 'x1', generator.ORDER_ATOMIC);
+    var location_y1 = generator.valueToCode(this, 'y1', generator.ORDER_ATOMIC);
+    var location_x2 = generator.valueToCode(this, 'x2', generator.ORDER_ATOMIC);
+    var location_y2 = generator.valueToCode(this, 'y2', generator.ORDER_ATOMIC);
+    var code = varName + '.show_line(' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', 1)\n';
+    return code;
+}
+
+export const display_rect = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var value_width = generator.valueToCode(this, 'width', generator.ORDER_ATOMIC);
+    var value_height = generator.valueToCode(this, 'height', generator.ORDER_ATOMIC);
+    var checkbox_fill = this.getFieldValue("fill") == 'TRUE' ? 'True' : 'False';
+    var size = this.getFieldValue('OP');
+    switch (checkbox_fill) {
+        case "True":
+            var code = varName + '.show_fill_rect(' + location_x + ', ' + location_y + ', ' + value_width + ', ' + value_height + ', ' + size + ')\n';
+            return code;
+        case "False":
+            var code = varName + '.show_rect(' + location_x + ', ' + location_y + ', ' + value_width + ', ' + value_height + ', ' + size + ')\n';
+            return code;
+    }
+}
+
+
+export const display_line = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var value_length = generator.valueToCode(this, 'length', generator.ORDER_ATOMIC);
+    var value_direction = this.getFieldValue("direction");
+    var code = varName + '.show_' + value_direction + '(' + location_x + ', ' + location_y + ', ' + value_length + ', 1)\n';
+    return code;
+}
+
+export const display_onoff = function (_, generator) {
+    var code = (this.getFieldValue('ONOFF') == 'ON') ? '1' : '0';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const image_shift = function (a, generator) {
+    generator.definitions_['import_matrix'] = 'import matrix';
+    var op = a.getFieldValue("OP");
+    var image = generator.valueToCode(a, 'img', generator.ORDER_ATOMIC);
+    var value = generator.valueToCode(a, 'val', generator.ORDER_ATOMIC);
+    var code = image + '.shift_' + op + '(' + value + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_fill = function (_, generator) {
+    var varName = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    generator.definitions_['import_machine'] = 'import machine';
+    var key = this.getFieldValue('key');
+    var code = varName + '.show_fill(' + key + ')\n';
+    return code;
+}
+
+// export const switch = function (_, generator) {
+//     var code = this.getFieldValue('flag');
+//     return [code, generator.ORDER_ATOMIC];
+// };
+
+export const display_animate = function (_, generator) {
+    // Boolean values true and false.
+    var name = this.getFieldValue("ANIMATION");
+    var code = 'matrix.Image.' + name;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const display_circle = function (_, generator) {
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var location_x = generator.valueToCode(this, 'x', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'y', generator.ORDER_ATOMIC);
+    var value_r = generator.valueToCode(this, 'r', generator.ORDER_ATOMIC);
+    var checkbox_fill = this.getFieldValue("fill") == 'TRUE' ? 'True' : 'False';
+    var size = this.getFieldValue('OP');
+    switch (checkbox_fill) {
+        case "True":
+            var code = varName + '.show_fill_circle(' + location_x + ', ' + location_y + ', ' + value_r + ', ' + size + ')\n';
+            return code;
+        case "False":
+            var code = varName + '.show_circle(' + location_x + ', ' + location_y + ', ' + value_r + ', ' + size + ')\n';
+            return code;
+    }
+}
+
+export const display_triangle = function (_, generator) {
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var location_x0 = generator.valueToCode(this, 'x0', generator.ORDER_ATOMIC);
+    var location_y0 = generator.valueToCode(this, 'y0', generator.ORDER_ATOMIC);
+    var location_x1 = generator.valueToCode(this, 'x1', generator.ORDER_ATOMIC);
+    var location_y1 = generator.valueToCode(this, 'y1', generator.ORDER_ATOMIC);
+    var location_x2 = generator.valueToCode(this, 'x2', generator.ORDER_ATOMIC);
+    var location_y2 = generator.valueToCode(this, 'y2', generator.ORDER_ATOMIC);
+    var checkbox_fill = this.getFieldValue("fill") == 'TRUE' ? 'True' : 'False';
+    var size = this.getFieldValue('OP');
+    switch (checkbox_fill) {
+        case "True":
+            var code = varName + '.show_fill_triangle(' + location_x0 + ', ' + location_y0 + ', ' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', ' + size + ')\n';
+            return code;
+        case "False":
+            var code = varName + '.show_triangle(' + location_x0 + ', ' + location_y0 + ', ' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', ' + size + ')\n';
+            return code;
+    }
+}
+
+export const display_oled_showBitmap = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'START_X', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'START_Y', generator.ORDER_ATOMIC);
+    var bmp = generator.valueToCode(this, 'bitmap_name', generator.ORDER_ATOMIC);
+    var w = generator.valueToCode(this, 'WIDTH', generator.ORDER_ATOMIC);
+    var h = generator.valueToCode(this, 'HEIGHT', generator.ORDER_ATOMIC);
+    var code = varName + '.show_bitmap(' + location_x + ', ' + location_y + ', ' + bmp + ',' + w + ',' + h + ')\n';
+    return code;
+}
+
+export const display_oled_drawPixel = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_ssd1306'] = 'import ssd1306';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var location_x = generator.valueToCode(this, 'POS_X', generator.ORDER_ATOMIC);
+    var location_y = generator.valueToCode(this, 'POS_Y', generator.ORDER_ATOMIC);
+    var code = varName + '.show_pixel(' + location_x + ', ' + location_y + ')\n';
+    return code;
+}
+
+//tm1650
+export const display_tm_use_i2c_init = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var clk = generator.valueToCode(this, 'CLK', generator.ORDER_ATOMIC);
+    var dio = generator.valueToCode(this, 'DIO', generator.ORDER_ATOMIC);
+    // var iv = generator.valueToCode(this, 'I2CSUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue("key");
+    var code;
+    if (key == 'TM1650') {
+        generator.definitions_['import_tm1650'] = 'import tm1650';
+        code = v + ' = tm1650.' + key + '(clk='+ clk +',dio='+ dio +')\n';
+    } else if (key == 'TM1637') {
+        generator.definitions_['import_tm1637'] = 'import tm1637';
+        code = v + ' = tm1637.' + key + '(clk='+ clk +',dio='+ dio +')\n';
+    }
+    return code;
+}
+
+export const display_tm1650_power = function (_, generator) {
+    // var type = this.getFieldValue("TYPE");
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var stat = this.getFieldValue("STAT");
+    var code = v + '.' + stat + "()\n";
+    return code;
+}
+
+export const display_tm1650_show_num = function (_, generator) {
+    // var type = this.getFieldValue("TYPE");
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var val = generator.valueToCode(this, 'VALUE', generator.ORDER_ATOMIC);
+    var code = v + ".shownum(" + val + ")\n";
+    return code;
+}
+
+export const display_tm1650_show_dot = function (_, generator) {
+    // var type = this.getFieldValue("TYPE");
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var n = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    var stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = v + '.showDP(' + n + ", " + stat + ")\n";
+    return code;
+}
+
+export const display_tm1650_set_brightness = function (_, generator) {
+    // var type = this.getFieldValue("TYPE");
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var val = generator.valueToCode(this, 'VALUE', generator.ORDER_ATOMIC);
+    var code = v + ".intensity(" + val + ")\n";
+    return code;
+}
+
+export const tft_use_spi_init = function (_, generator) {
+    generator.definitions_['import_st7789'] = 'import st7789';
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var font = '';
+    if (['mpython', 'mixgo_pe', 'mixgo_nova'].indexOf(version) >= 0) {
+        font = '0x700000'
+    } else if (['mixgo_sant'].indexOf(version) >= 0) {
+        font = '0xE00000'
+    } else {
+        font = '0x3A0000'
+    }
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var sv = generator.valueToCode(this, 'SPISUB', generator.ORDER_ATOMIC);
+    var pv = generator.valueToCode(this, 'PINCS', generator.ORDER_ATOMIC);
+    var dv = generator.valueToCode(this, 'PINDC', generator.ORDER_ATOMIC);
+    var w = generator.valueToCode(this, 'WIDTH', generator.ORDER_ATOMIC);
+    var h = generator.valueToCode(this, 'HEIGHT', generator.ORDER_ATOMIC);
+    var op = this.getFieldValue('rotate');
+    var code = v + ' = st7789.ST7789(' + sv + ', ' + w + ', ' + h + ', dc_pin=' + dv + ', cs_pin=' + pv + ', rotation=' + op + ', font_address=' + font + ')\n';
+    return code;
+}
+
+export const tft_show_image_xy = function (_, generator) {
+    generator.definitions_['import_st7789'] = 'import st7789';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var color = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    if (color.slice(0, 2) == "0x") {
+        var code = v + ".image(" + data + ', x=' + x + ', y=' + y + ', size=' + size + ', color=' + color + ")\n";
+    } else {
+        const rgbValues = color.match(/\d+/g);
+        const r = parseInt(rgbValues[0]);
+        const g = parseInt(rgbValues[1]);
+        const b = parseInt(rgbValues[2]);
+        var rgb = "0x" + ((r << 16) + (g << 8) + b).toString(16).padStart(4, "0");
+        var rgb565 = (rgb & 0xf80000) >> 8 | (rgb & 0xfc00) >> 5 | (rgb & 0xff) >> 3;
+        var code = v + ".image(" + data + ', x= ' + x + ',y=' + y + ', size=' + size + ', color=0x' + rgb565.toString(16) + ")\n";
+    }
+    return code;
+}
+
+export const display_color_seclet = function (_, generator) {
+    var colour = this.getFieldValue('COLOR');
+    var code = '0x' + colour.slice(1) + ''
+    var rgb565 = (code & 0xf80000) >> 8 | (code & 0xfc00) >> 5 | (code & 0xff) >> 3
+    return ['0x' + rgb565.toString(16), generator.ORDER_ATOMIC];
+}
+
+export const tft_show_image_or_string_delay = function (_, generator) {
+    generator.definitions_['import_st7789'] = 'import st7789';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var space = generator.valueToCode(this, 'space', generator.ORDER_ASSIGNMENT);
+    var color = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var op = this.getFieldValue('center');
+    if (color.slice(0, 2) == "0x") {
+        var code = v + ".shows(" + data + ', x=' + x + ', y=' + y + ', size=' + size + ', space=' + space + ', center=' + op + ', color=' + color + ")\n";
+    } else {
+        const rgbValues = color.match(/\d+/g);
+        const r = parseInt(rgbValues[0]);
+        const g = parseInt(rgbValues[1]);
+        const b = parseInt(rgbValues[2]);
+        var rgb = "0x" + ((r << 16) + (g << 8) + b).toString(16).padStart(4, "0");
+        var rgb565 = (rgb & 0xf80000) >> 8 | (rgb & 0xfc00) >> 5 | (rgb & 0xff) >> 3;
+        var code = v + ".shows(" + data + ', x=' + x + ', y=' + y + ', size=' + size + ', space=' + space + ', center=' + op + ', color=0x' + rgb565.toString(16) + ")\n";
+    }
+    return code;
+}
+
+export const tft_show_frame_string_delay = function (_, generator) {
+    generator.definitions_['import_st7789'] = 'import st7789';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var color = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    if (color.slice(0, 2) == "0x") {
+        var code = v + ".frame(" + data + ', size=' + size + ', delay=' + time + ', color=' + color + ")\n";
+    } else {
+        const rgbValues = color.match(/\d+/g);
+        const r = parseInt(rgbValues[0]);
+        const g = parseInt(rgbValues[1]);
+        const b = parseInt(rgbValues[2]);
+        var rgb = "0x" + ((r << 16) + (g << 8) + b).toString(16).padStart(4, "0");
+        var rgb565 = (rgb & 0xf80000) >> 8 | (rgb & 0xfc00) >> 5 | (rgb & 0xff) >> 3;
+        var code = v + ".frame(" + data + ', size=' + size + ', delay=' + time + ', color=0x' + rgb565.toString(16) + ")\n";
+    }
+    return code;
+}
+
+export const tft_scroll_string_delay = function (_, generator) {
+    generator.definitions_['import_st7789'] = 'import st7789';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var space = generator.valueToCode(this, 'space', generator.ORDER_ASSIGNMENT);
+    var color = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    if (color.slice(0, 2) == "0x") {
+        var code = v + ".scroll(" + data + ', y=' + y + ', size=' + size + ', speed=' + time + ', space=' + space + ', color=' + color + ")\n";
+    } else {
+        const rgbValues = color.match(/\d+/g);
+        const r = parseInt(rgbValues[0]);
+        const g = parseInt(rgbValues[1]);
+        const b = parseInt(rgbValues[2]);
+        var rgb = "0x" + ((r << 16) + (g << 8) + b).toString(16).padStart(4, "0");
+        var rgb565 = (rgb & 0xf80000) >> 8 | (rgb & 0xfc00) >> 5 | (rgb & 0xff) >> 3;
+        var code = v + ".scroll(" + data + ', y=' + y + ', size=' + size + ', speed=' + time + ', space=' + space + ', color=0x' + rgb565.toString(16) + ")\n";
+    }
+    return code;
+}
+
+export const tft_fill = function (_, generator) {
+    generator.definitions_['import_st7789'] = 'import st7789';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = v + '.fill(st7789.' + key + ')\n';
+    return code;
+}
+
+export const tft_line_arbitrarily = function (_, generator) {
+    generator.definitions_['import_st7789'] = 'import st7789';
+    var varName = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var location_x1 = generator.valueToCode(this, 'x1', generator.ORDER_ATOMIC);
+    var location_y1 = generator.valueToCode(this, 'y1', generator.ORDER_ATOMIC);
+    var location_x2 = generator.valueToCode(this, 'x2', generator.ORDER_ATOMIC);
+    var location_y2 = generator.valueToCode(this, 'y2', generator.ORDER_ATOMIC);
+    var color = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    if (color.slice(0, 2) == "0x") {
+        var code = varName + '.line(' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', color=' + color + ')\n';
+    } else {
+        const rgbValues = color.match(/\d+/g);
+        const r = parseInt(rgbValues[0]);
+        const g = parseInt(rgbValues[1]);
+        const b = parseInt(rgbValues[2]);
+        var rgb = "0x" + ((r << 16) + (g << 8) + b).toString(16).padStart(4, "0");
+        var rgb565 = (rgb & 0xf80000) >> 8 | (rgb & 0xfc00) >> 5 | (rgb & 0xff) >> 3;
+        var code = varName + '.line(' + location_x1 + ', ' + location_y1 + ', ' + location_x2 + ', ' + location_y2 + ', color=0x' + rgb565.toString(16) + ')\n';
+    }
+    return code;
+}
+
+export const display_lcd_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 addr = generator.valueToCode(this, 'ADDR', generator.ORDER_ATOMIC);
+    var code;
+    generator.definitions_['import_i2clcd'] = 'import i2clcd';
+    code = v + ' = i2clcd.LCD' + "(" + iv + ', lcd_width=' + key + ', i2c_addr=' + addr + ')\n';
+    return code;
+}
+
+export const lcd_show_image_or_string_delay = function (_, generator) {
+    generator.definitions_['import_i2clcd'] = 'import i2clcd';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var op = this.getFieldValue('center');
+    var code = v + ".shows(" + data + ', column=' + x + ', line=' + y + ',center = ' + op + ")\n";
+    return code;
+}
+
+export const lcd_print_string = function (_, generator) {
+    generator.definitions_['import_i2clcd'] = 'import i2clcd';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var delay = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var code = v + ".print(" + data + ', column=' + x + ', line=' + y + ', delay=' + delay + ")\n";
+    return code;
+}
+
+export const lcd_backlight = function (_, generator) {
+    generator.definitions_['import_i2clcd'] = 'import i2clcd';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = v + '.backlight(' + key + ')\n';
+    return code;
+}
+
+export const lcd_clear = function (block, generator) {
+    generator.definitions_['import_i2clcd'] = 'import i2clcd';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.clear()\n';
+    return code;
+}
+
+export const display_oled_use_i2c_init = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var iv = generator.valueToCode(this, 'I2CSUB', generator.ORDER_ATOMIC);
+    var addr = generator.valueToCode(this, 'ADDR', generator.ORDER_ATOMIC);
+    var m = this.getFieldValue("driver");
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    var font = '';
+    if (['mpython', 'mixgo_pe', 'mixgo_nova'].indexOf(version) >= 0) {
+        font = '0x700000'
+    } else if (['mixgo_sant'].indexOf(version) >= 0) {
+        font = '0xE00000'
+    } else {
+        font = '0x3A0000'
+    }
+    var code;
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    code = v + ' = oled128x64.OLED' + "(" + iv + ', address=' + addr + ', font_address=' + font + ', types=' + m + ')\n';
+
+    return code;
+}
+
+export const extern_oled_show_image = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".image(" + data + ")\n";
+    return code;
+}
+
+export const extern_oled_show_image_xy = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var code = v + ".image(" + data + ', x=' + x + ', y=' + y + ', size=' + size + ")\n";
+    return code;
+}
+
+export const extern_oled_show_string = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".shows(" + data + ")\n";
+    return code;
+}
+
+export const extern_oled_show_image_or_string_delay = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var space = generator.valueToCode(this, 'space', generator.ORDER_ASSIGNMENT);
+    var op = this.getFieldValue('center');
+    var code = v + ".shows(" + data + ', x=' + x + ', y=' + y + ', size=' + size + ', space=' + space + ', center=' + op + ")\n";
+    return code;
+}
+
+export const extern_oled_show_frame_string = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".frame(" + data + ")\n";
+    return code;
+}
+
+export const extern_oled_show_frame_string_delay = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var code = v + ".frame(" + data + ', size=' + size + ', delay=' + time + ")\n";
+    return code;
+}
+
+export const extern_oled_scroll_string = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var code = v + ".scroll(" + data + ")\n";
+    return code;
+}
+
+export const extern_oled_scroll_string_delay = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var size = generator.valueToCode(this, 'size', generator.ORDER_ASSIGNMENT);
+    var time = generator.valueToCode(this, 'time', generator.ORDER_ASSIGNMENT);
+    var space = generator.valueToCode(this, 'space', generator.ORDER_ASSIGNMENT);
+    var code = v + ".scroll(" + data + ', y=' + y + ', size=' + size + ', speed=' + time + ', space=' + space + ")\n";
+    return code;
+}
+
+export const extern_oled_clear = function (block, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.fill(0)\n' + v + '.show()\n';
+    return code;
+}
+
+export const extern_oled_shift = function (a, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var op = a.getFieldValue("OP");
+    var value = generator.valueToCode(a, 'val', generator.ORDER_ATOMIC);
+    var code = v + '.' + op + '(' + value + ')\n';
+    return code;
+}
+
+export const extern_oled_get_pixel = function (block, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var value_x = generator.valueToCode(block, 'x', generator.ORDER_ATOMIC);
+    var value_y = generator.valueToCode(block, 'y', generator.ORDER_ATOMIC);
+    var code = v + '.pixel(int(' + value_x + '), int(' + value_y + '))';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const extern_oled_bright_point = function (_, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(this, 'x', generator.ORDER_ASSIGNMENT);
+    var y = generator.valueToCode(this, 'y', generator.ORDER_ASSIGNMENT);
+    var dropdown_stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = v + '.pixel(int(' + x + '), int(' + y + '), ' + dropdown_stat + ")\n" + v + '.show()\n';
+    return code;
+}
+
+export const extern_oled_shape_rect = function (block, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(block, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(block, 'y', generator.ORDER_ATOMIC);
+    var w = generator.valueToCode(block, 'w', generator.ORDER_ATOMIC);
+    var h = generator.valueToCode(block, 'h', generator.ORDER_ATOMIC);
+    var state = block.getFieldValue('state');
+    var shape = block.getFieldValue('shape');
+    var code = v + '.' + shape + '(' + x + ', ' + y + ', ' + w + ', ' + h + ', ' + state + ')\n' + v + '.show()\n';
+    return code;
+}
+
+export const extern_oled_hvline = function (block, generator) { //水平线
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var x = generator.valueToCode(block, 'x', generator.ORDER_ATOMIC);
+    var y = generator.valueToCode(block, 'y', generator.ORDER_ATOMIC);
+    var var_length = generator.valueToCode(block, 'length', generator.ORDER_ATOMIC);
+    var state = block.getFieldValue('state');
+    var hv = block.getFieldValue('dir_h_v');
+    var code = v + '.' + (('0' == hv) ? 'v' : 'h') + 'line(' + x + ', ' + y + ', ' + var_length + ', ' + state + ')\n' + v + '.show()\n';
+    return code;
+}
+
+export const extern_oled_line = function (block, generator) {
+    generator.definitions_['import_oled128x64'] = 'import oled128x64';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var x1 = generator.valueToCode(block, 'x1', generator.ORDER_ATOMIC);
+    var y1 = generator.valueToCode(block, 'y1', generator.ORDER_ATOMIC);
+    var x2 = generator.valueToCode(block, 'x2', generator.ORDER_ATOMIC);
+    var y2 = generator.valueToCode(block, 'y2', generator.ORDER_ATOMIC);
+    var state = block.getFieldValue('state');
+    var code = v + '.line(' + x1 + ', ' + y1 + ', ' + x2 + ', ' + y2 + ', ' + state + ')\n' + v + '.show()\n';
+    return code;
+}

mixly/boards/default_src/micropython/generators/factory.js

@@ -0,0 +1,95 @@
+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 folding_block = function (_, generator) {
+    var comment = this.getFieldValue('peien');
+    comment = "#" + comment;
+    var branch = generator.statementToCode(this, 'DO');
+    branch = branch.replace(/(^\s*)|(\s*$)/g, "");//去除两端空格
+    branch = branch.replace(/(\n\s\s\s\s)/g, "\n");//去除换行时空格
+    return comment + '\n' + branch + '\n';
+}

mixly/boards/default_src/micropython/generators/inout.js

@@ -0,0 +1,158 @@
+import * as Blockly from 'blockly/core';
+
+// ok
+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_write = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = "";
+    code += dropdown_pin + '.value(' + dropdown_stat + ')\n'
+    return code;
+}
+
+// ok
+export const inout_digital_read = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = "";
+    code = dropdown_pin + '.value()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// ok
+export const inout_pwm_analog_write = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    //var dropdown_stat = this.getFieldValue('STAT');
+    var value_num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    //generator.setups_['setup_output'+dropdown_pin] = 'pinMode('+dropdown_pin+', OUTPUT);';
+    var code = dropdown_pin + '.duty_u16(' + value_num + ')\n';
+    return code;
+}
+
+// ok
+export const inout_analog_write = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    //var dropdown_stat = this.getFieldValue('STAT');
+    var value_num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    //generator.setups_['setup_output'+dropdown_pin] = 'pinMode('+dropdown_pin+', OUTPUT);';
+    var code = dropdown_pin + '.write(' + value_num + ')\n';
+    return code;
+}
+
+// ok
+export const inout_analog_write_set = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var value_num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = dropdown_pin + '.set_analog_' + key + '(' + value_num + ')\n';
+    //var code = 'pin' + dropdown_pin  + '.set_analog_period(' + value_num + ')\n';
+    return code;
+}
+
+export const inout_pwm_analog_write_set_freq = function (_, generator) {
+    //generator.definitions_['import_machine_Pin'] = "from machine import Pin";
+    // generator.definitions_['import_machine_PWM'] = "from machine import PWM";
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var value_num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    var code = dropdown_pin + '.freq(' + value_num + ')\n';
+    //var code = 'pin' + dropdown_pin  + '.set_analog_period(' + value_num + ')\n';
+    return code;
+}
+
+// ok
+export const inout_analog_read = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    //generator.setups_['setup_input_'+dropdown_pin] = 'pinMode('+dropdown_pin+', INPUT);';
+    var code = dropdown_pin + '.read_u16()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// ok
+export const inout_pin_pressed = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var pin = generator.valueToCode(this, 'pin', generator.ORDER_ATOMIC);
+    var code = pin + '.read()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const inout_pin_attachInterrupt = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    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 code = 'machine.Pin(' + dropdown_pin + ').irq' + '(handler=' + atta + ', trigger=' + dropdown_mode + ')\n'
+    //var funcName = 'attachInterrupt_func_' + dropdown_pin;
+    //var branch = generator.statementToCode(this, 'DO') || generator.PASS;
+    //var code2 = 'def' + ' ' + funcName + '(p):\n' + branch + '\n';
+    //generator.setups_[funcName] = code2;
+    return code;
+}
+
+export const inout_digital_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    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 + ' = machine.Pin(' + dropdown_pin + ', ' + dropdown_mode + ')\n';
+    return code;
+}
+
+export const inout_pwm_analog_write_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var pin_obj = this.getFieldValue('PIN_OBJ') || 'pwm#';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var varName = (pin_obj == 'pwm#') ? 'pwm' + dropdown_pin : generator.variableDB_.getName(pin_obj, Blockly.Variables.NAME_TYPE);
+    var code = varName + ' = machine.PWM(machine.Pin(' + dropdown_pin + '))\n';
+    return code;
+}
+
+// ok
+export const inout_analog_write_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var pin_obj = this.getFieldValue('PIN_OBJ') || 'dac#';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var varName = (pin_obj == 'dac#') ? 'dac' + dropdown_pin : generator.variableDB_.getName(pin_obj, Blockly.Variables.NAME_TYPE);
+    var code = varName + ' = machine.DAC(machine.Pin(' + dropdown_pin + '))\n';
+    return code;
+}
+
+export const inout_analog_read_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var pin_obj = this.getFieldValue('PIN_OBJ') || 'adc#';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var varName = (pin_obj == 'adc#') ? 'adc' + dropdown_pin : generator.variableDB_.getName(pin_obj, Blockly.Variables.NAME_TYPE);
+    var code = varName + ' = machine.ADC(machine.Pin(' + dropdown_pin + '))\n';
+    return code;
+}
+
+export const inout_analog_atten = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    //var dropdown_stat = this.getFieldValue('STAT');
+    var value_atten = this.getFieldValue('atten')
+    var code = dropdown_pin + '.atten(' + value_atten + ')\n';
+    return code;
+}
+
+// ok
+export const inout_pin_pressed_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var pin_obj = this.getFieldValue('PIN_OBJ') || 'tc#';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var varName = (pin_obj == 'tc#') ? 'tc' + dropdown_pin : generator.variableDB_.getName(pin_obj, Blockly.Variables.NAME_TYPE);
+    var code = varName + ' = machine.TouchPad(machine.Pin(' + dropdown_pin + '))\n';
+    return code;
+}

mixly/boards/default_src/micropython/generators/iot.js

@@ -0,0 +1,366 @@
+export const iot_wifi_connect = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var username = generator.valueToCode(this, 'WIFINAME', generator.ORDER_ATOMIC);
+    var password = generator.valueToCode(this, 'PASSWORD', generator.ORDER_ATOMIC);
+    var code = 'mixiot.wlan_connect(' + username + ', ' + password + ')\n';
+    return code;
+}
+
+export const iot_onenet_connect = function (_, generator) {
+    generator.definitions_['import_onenet'] = "import onenet";
+    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) || 'None';
+    var code = v + ' = onenet.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_onenet'] = "import onenet";
+    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_onenet'] = "import onenet";
+    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_onenet'] = "import onenet";
+    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_onenet'] = "import onenet";
+    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 (let n = 0; n < this.itemCount_; n++) {
+        var keyName = this.getFieldValue('KEY' + n);
+        ck[n] = keyName;
+    }
+    for (let n = 0; n < this.itemCount_; n++) {
+        cv[n] = generator.valueToCode(this, 'ADD' + n,
+            generator.ORDER_NONE) || default_value;
+    }
+    var code = v + ".publish({";
+    for (let 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;
+}
+
+export const iot_mixio_connect = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    generator.definitions_['import_machine'] = "import machine";
+    generator.definitions_['import_ubinascii_hexlify'] = "from ubinascii import hexlify";
+    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 project = generator.valueToCode(this, 'PROJECT', generator.ORDER_ATOMIC);
+    //var subscribe = generator.valueToCode(this, 'SUB', generator.ORDER_ASSIGNMENT) || '0';
+    var a = "'" + username.replace("'", "").replace("'", "") + "/" + project.replace("'", "").replace("'", "") + "/'"
+    var code = 'MQTT_USR_PRJ = ' + a + '\n' + 'mqtt_client = mixiot.init_MQTT_client(' + server + ', ' + username + ', ' + password + ', MQTT_USR_PRJ)\n';
+    return code;
+}
+
+export const IOT_MIXIO_PUBLISH = function (_, generator) {
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var msg = generator.valueToCode(this, 'MSG', generator.ORDER_ATOMIC);
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var code = 'mqtt_client.publish(MQTT_USR_PRJ + ' + topic + ', ' + msg + ')\n';
+    return code;
+}
+
+export const IOT_MIXIO_PUBLISHEX = function (_, generator) {
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var msg = generator.valueToCode(this, 'MSG', generator.ORDER_ATOMIC);
+    var q = this.getFieldValue('quality');
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var code = 'mqtt_client.publish(MQTT_USR_PRJ + ' + topic + ', ' + msg + ', qos='+ q +')\n';
+    return code;
+}
+
+export const IOT_MIXIO_SUBSCRIBE = function (_, generator) {
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var method = generator.valueToCode(this, 'METHOD', generator.ORDER_ATOMIC);
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var code = 'mqtt_client.set_callback(' + topic + ',' + method + ', MQTT_USR_PRJ)\n';
+    code += 'mqtt_client.subscribe(MQTT_USR_PRJ + ' + topic + ')\n';
+    return code;
+}
+
+export const iot_mixio_disconnect = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var code = 'mqtt_client.disconnect(MQTT_USR_PRJ)\n';
+    return code;
+}
+
+export const iot_mixio_connect_only = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var code = 'mqtt_client.connect()\n';
+    return code;
+}
+
+export const iot_mixio_check = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var code = 'mqtt_client.check_msg()\n';
+    return code;
+}
+
+export const iot_mixio_format_topic = function (_, generator) {
+    var code = 'mqtt_client.decode("utf-8").split("/")[-1]';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_mixio_format_msg = function (_, generator) {
+    var code = 'mqtt_client.decode("utf-8")';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const IOT_FORMATTING = function (_, generator) {
+    generator.definitions_['import_mixpy'] = "import mixpy";
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = 'mixpy.format_content(' + v + ', mqtt_client.client_id)';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const IOT_FORMAT_STRING = function (_, generator) {
+    generator.definitions_['import_mixpy'] = "import mixpy";
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = 'mixpy.format_str(' + v + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const IOT_EMQX_INIT_AND_CONNECT_BY_SHARE_CODE = function (_, generator) {
+    var server = generator.valueToCode(this, 'SERVER', generator.ORDER_ATOMIC);
+    // var port = '1883';
+    var share_code = generator.valueToCode(this, 'KEY', generator.ORDER_ATOMIC);
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    generator.definitions_['import_mixpy_analyse_sharekey'] = "from mixpy import analyse_sharekey";
+    // var mac_address = 'str(binascii.hexlify(wifi.radio.mac_address))[2:14]'
+    // var socket_pool = 'socketpool.SocketPool(wifi.radio)'
+    // var ssl_context = 'ssl.create_default_context()'
+    var code = 'sk = analyse_sharekey(\'https://' + server.substring(1, server.length - 1) + '/mixio-php/sharekey.php?sk=' + share_code + '\')\n' +
+        'MQTT_USR_PRJ = sk[0]+\'/\'+sk[1]+\'/\'\n';
+    
+    // 根据server是否包含":"来生成不同的mqtt_client代码
+    if (server.indexOf(':') !== -1) {
+        // 包含":"，使用server.substring(1, server.indexOf(':'))
+        code += 'mqtt_client = mixiot.init_MQTT_client(' + server.substring(0, server.indexOf(':')) + server.substring(server.length - 1) + ', sk[0], sk[2]' + ', MQTT_USR_PRJ)\n';
+    } else {
+        // 不包含":"，使用完整的server（去掉首尾的引号）
+        code += 'mqtt_client = mixiot.init_MQTT_client(' + server.substring(0, server.length - 1)+ server.substring(server.length - 1) + ', sk[0], sk[2]' + ', MQTT_USR_PRJ)\n';
+    }
+    return code;
+}
+
+
+export const iot_mixly_key = function (_, generator) {
+    var code = this.getFieldValue('VISITOR_ID');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const IOT_EMQX_INIT_AND_CONNECT_BY_MIXLY_CODE = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var server = generator.valueToCode(this, 'SERVER', generator.ORDER_ATOMIC);
+    // var port = '1883';
+    var username = '"MixIO_public"';
+    var password = '"MixIO_public"';
+    var mixly_code = generator.valueToCode(this, 'KEY', generator.ORDER_ATOMIC);
+    var a = '"MixIO/' + mixly_code + '/default/"'
+    // var mac_address = 'str(binascii.hexlify(wifi.radio.mac_address))[2:14]'
+    // var socket_pool = 'socketpool.SocketPool(wifi.radio)'
+    // var ssl_context = 'ssl.create_default_context()'
+    var code = 'MQTT_USR_PRJ = ' + a + '\n' + 'mqtt_client = mixiot.init_MQTT_client(' + server + ', ' + username + ', ' + password + ', MQTT_USR_PRJ)\n';
+    return code;
+}
+
+export const IOT_EMQX_PING = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var code = 'mqtt_client.pingSync()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const IOT_MIXIO_NTP = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var code = 'mixiot.ntp(' + addr + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_client_onboard = function (_, generator) {
+    var code = 'mqtt_client';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_http_client = function (_, generator) {
+    generator.definitions_['import_debugnet'] = "import debugnet";
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = 'HTTP_client = debugnet.request("GET", ' + addr + ', debug=' + key + ')\n';
+    return code;
+}
+
+export const iot_http_data = function (_, generator) {
+    generator.definitions_['import_debugnet'] = "import debugnet";
+    var key = this.getFieldValue('key');
+    var code = 'HTTP_client.' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_mqtt_client = function (_, generator) {
+    generator.definitions_['import_debugnet'] = "import debugnet";
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key2');
+    var code = 'mqtt_client = debugnet.init_MQTT_client(' + addr + ', "MixIO_public", "MixIO_public", "MixIO/3QBAGKRL/default/",debug=' + key + ')\n';
+    code += 'mqtt_client.subscribe("$SYS/hello")\n';
+    return code;
+}
+
+export const iot_mqtt_data = function (_, generator) {
+    generator.definitions_['import_mixiot'] = "import mixiot";
+    var key = this.getFieldValue('key');
+    var code = 'mqtt_client.' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_connect_ollama = function (_, generator) {
+    generator.definitions_['import_ollama'] = "from ollama import Ollama";
+    var ser = generator.valueToCode(this, 'SERVER', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'NAME', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'NUMBER', generator.ORDER_ATOMIC);
+    var code = 'llm = Ollama(' + ser + ', ' + name + ', ' + num + ')\n';
+    return code;
+}
+
+export const IOT_CONNECT_OLLAMA = iot_connect_ollama;
+
+export const iot_connect_openai = function (_, generator) {
+    generator.definitions_['import_openai'] = "from openai import OpenAI";
+    var ser = generator.valueToCode(this, 'SERVER', generator.ORDER_ATOMIC);
+    var key = generator.valueToCode(this, 'KEY', generator.ORDER_ATOMIC);
+    var name = generator.valueToCode(this, 'NAME', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'NUMBER', generator.ORDER_ATOMIC);
+    var code = `llm = OpenAI(${ser}, ${key}, ${name}, ${num})\n`;
+    return code;
+}
+
+export const use_ollama_llm_to_chat = function (_, generator) {
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var method = generator.valueToCode(this, 'METHOD', generator.ORDER_ATOMIC);
+    var code = 'llm.chat(' + topic + ', ' + method + ')\n';
+    return code;
+}
+
+export const use_ollama_llm_to_chat_return = function (_, generator) {
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var code = 'llm.chat(' + topic + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// export const ollama_set_timeout = function (_,generator) {
+//     var t = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+//     var code = 'llm.set_timeout(' + t + ')\n';
+//     return code;
+// }
+
+// export const ollama_set_max_retries = function (_,generator) {
+//     var t = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+//     var code = 'llm.set_max_retries(' + t + ')\n';
+//     return code;
+// }
+
+// export const ollama_set_custom_url = function (_,generator) {
+//     var t = generator.valueToCode(this, 'TEXT', generator.ORDER_ATOMIC);
+//     var code = 'llm.set_custom_url(' + t + ')\n';
+//     return code;
+// }
+
+// export const ollama_select_model = function (_,generator) {
+//     var t = generator.valueToCode(this, 'TEXT', generator.ORDER_ATOMIC);
+//     var code = 'llm.select_model(' + t + ')\n';
+//     return code;
+// }
+
+// export const ollama_clear_user_history = function (_,generator) {
+//     var code = 'llm.clear_user_history()\n';
+//     return code;
+// }
+
+export const ollama_empty_history = function () {
+    var code = 'llm.empty_history()\n';
+    return code;
+}
+
+export const iot_tiny_web_db_init = function (_,generator) {
+    generator.definitions_['import_tiny_webdb'] = 'import tiny_webdb';
+    const addr = generator.valueToCode(this, 'ADDR', generator.ORDER_ATOMIC);
+    const username = generator.valueToCode(this, 'USERNAME', generator.ORDER_ATOMIC);
+    const password = generator.valueToCode(this, 'PASSWORD', generator.ORDER_ATOMIC);
+    const code = `webdb = tiny_webdb.TinyWebDB(${addr}, ${username}, ${password})\n`;
+    return code;
+}
+
+export const iot_tiny_web_db_init_with_mqtt = function (_,generator) {
+    generator.definitions_['import_tiny_webdb'] = 'import tiny_webdb';
+    const mqtt = generator.valueToCode(this, 'MQTT', generator.ORDER_ATOMIC);
+    const code = `webdb = tiny_webdb.TinyWebDB(${mqtt})\n`;
+    return code;
+}
+
+export const iot_tiny_web_db_update = function (_,generator) {
+    const tag = generator.valueToCode(this, 'TAG', generator.ORDER_ATOMIC);
+    const value = generator.valueToCode(this, 'VALUE', generator.ORDER_ATOMIC);
+    const code = `webdb.update(${tag}, ${value})\n`;
+    return code;
+}
+
+export const iot_tiny_web_db_get = function (_,generator) {
+    const tag = generator.valueToCode(this, 'TAG', generator.ORDER_ATOMIC);
+    const code = `webdb.get(${tag})`;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_tiny_web_db_count = function (_,generator) {
+    const code = 'webdb.count()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_tiny_web_db_search = function (_,generator) {
+    const no = generator.valueToCode(this, 'NO', generator.ORDER_ATOMIC);
+    const count = generator.valueToCode(this, 'COUNT', generator.ORDER_ATOMIC);
+    const tag = generator.valueToCode(this, 'TAG', generator.ORDER_ATOMIC);
+    const dtype = this.getFieldValue('DTYPE');
+    const code = `webdb.search(${no}, ${count}, ${tag}, '${dtype}')`;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const iot_tiny_web_db_delete = function (_,generator) {
+    const tag = generator.valueToCode(this, 'TAG', generator.ORDER_ATOMIC);
+    const code = `webdb.delete(${tag})\n`;
+    return code;
+}

mixly/boards/default_src/micropython/generators/network.js

@@ -0,0 +1,319 @@
+import * as Blockly from 'blockly/core';
+
+export const network_init = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var mode = this.getFieldValue('mode');
+    return "" + varName + " = network.WLAN(network." + mode + "_IF);\n";
+}
+
+// export const network_connect = function() {
+//     generator.definitions_['import_network'] = "import network";
+//     // generator.setups_['class_wlan'] ='wlan.active(True)\n';
+//     var varName =generator.valueToCode(this, 'VAR',generator.ORDER_ATOMIC);
+//     var id = generator.valueToCode(this, 'id', generator.ORDER_ATOMIC);
+//     var password = generator.valueToCode(this, 'password', generator.ORDER_ATOMIC);
+//     return "if not "+varName+".isconnected():\n"+
+//            "  "+varName+".connect("+id+","+password+")\n"+
+//            "  while not "+varName+".isconnected():\n"+
+//            "    pass\n";
+// }
+
+export const network_connect = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    // generator.setups_['class_wlan'] ='wlan.active(True)\n';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var id = generator.valueToCode(this, 'id', generator.ORDER_ATOMIC);
+    var password = generator.valueToCode(this, 'password', generator.ORDER_ATOMIC);
+    return "" + varName + ".connect(" + id + ", " + password + ")\n"
+}
+
+export const network_wifi_connect = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = varName + '.isconnected()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_get_connect = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var mode = this.getFieldValue('mode');
+    var code = "" + varName + ".ifconfig()[" + mode + "]";
+    return [code, generator.ORDER_ATOMIC]
+}
+
+export const network_stop = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    return "" + varName + ".disconnect()\n";
+}
+
+export const network_open = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var op = this.getFieldValue('op');
+    var code = "" + varName + ".active(" + op + ")\n";
+    return code;
+}
+
+export const network_is_active = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".active()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_get_wifi = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var op = this.getFieldValue('op');
+    var code = "" + varName + ".config('" + op + "')";
+    return [code, generator.ORDER_ATOMIC]
+}
+
+export const network_ap_connect = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    // generator.setups_['class_wlan'] ='ap = network.WLAN(network.AP_IF)\n'+'ap.active(True)\n';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var essid = generator.valueToCode(this, 'essid', generator.ORDER_ATOMIC);
+    var pw = generator.valueToCode(this, 'password', generator.ORDER_ATOMIC);
+    var channel = generator.valueToCode(this, 'channel', generator.ORDER_ATOMIC);
+    return "" + varName + ".config(essid = " + essid + ", channel=" + channel + ",password="+ pw +")\n";
+}
+
+export const network_scan = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".scan()";
+    return [code, generator.ORDER_ATOMIC];
+
+}
+
+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'
+}
+
+export const network_socket_init = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    generator.definitions_['import_socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var mode = this.getFieldValue('mode');
+    if (mode == 'UDP') {
+        mode = 'socket.SOCK_DGRAM'
+    }
+    else if (mode == 'TCP') {
+        mode = 'socket.SOCK_STREAM'
+    }
+    return "" + varName + " = socket.socket(socket.AF_INET, " + mode + ")\n";
+}
+
+export const network_socket_bind = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    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 + ".bind(" + address + ")\n";
+}
+
+export const network_socket_connect = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    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(socket.getaddrinfo" + address + "[0][-1])\n";
+}
+
+export const network_socket_listen = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    generator.definitions_['import_socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var queue = generator.valueToCode(this, 'queue', generator.ORDER_ATOMIC);
+    return "" + varName + ".listen(" + queue + ")\n";
+}
+
+export const network_socket_accept = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    generator.definitions_['import_socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".accept()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_socket_readline = function (_, generator) {
+    generator.definitions_['import_network'] = 'import network';
+    generator.definitions_['import_socket'] = 'import socket';
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = varName + '.readline()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_socket_receive = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    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_network'] = "import network";
+    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_receive_from = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    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 + ".recvfrom(" + size + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const network_socket_send_to = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    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 address = generator.valueToCode(this, 'address', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".sendto(" + content + ", " + address + ")\n";
+    return code;
+}
+
+export const network_socket_close = function (_, generator) {
+    generator.definitions_['import_network'] = "import network";
+    generator.definitions_['import_socket'] = "import socket";
+    var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "" + varName + ".close()\n";
+    return code;
+}
+
+export const requests_get = function (_, generator) {
+    generator.definitions_.import_requests = "import requests";
+    var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
+        Blockly.Variables.NAME_TYPE);
+    var str = generator.valueToCode(this, 'DOMAIN', generator.ORDER_ATOMIC);
+    var code = varName + '= ' + 'requests.get(' + str + ')\n';
+    return code;
+}
+
+export const requests_attribute = function (_, generator) {
+    generator.definitions_.import_requests = "import requests";
+    var varName = generator.valueToCode(this, 'VAL', generator.ORDER_ASSIGNMENT) || '0';
+    var attr = this.getFieldValue('ATTR');
+    var code = varName + "." + attr;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const requests_method = function (_, generator) {
+    generator.definitions_.import_requests = "import requests";
+    var method = this.getFieldValue('DIR');
+    var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = "requests." + method + "(" + str + ')\n';
+    return code;
+}
+
+export const ntptime_time = function (_, generator) {
+    generator.definitions_['import_ntptime'] = "import ntptime";
+    var str = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var code = "ntptime.time(host=" + str + ")";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const ntptime_address = function (_, generator) {
+    var code = "'" + this.getFieldValue('op') + "'";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const requests_get2 = function (_, generator) {
+    generator.definitions_['import_urequests'] = "import urequests";
+    var dropdown_type = this.getFieldValue('TYPE');
+    var str = generator.valueToCode(this, 'URL', generator.ORDER_ATOMIC);
+    var code = 'urequests.' + dropdown_type + '(' + str + ')';
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const requests_attribute2 = function (_, generator) {
+    generator.definitions_['import_urequests'] = "import urequests";
+    var varName = generator.valueToCode(this, 'VAL', generator.ORDER_ASSIGNMENT) || '0';
+    var attr = this.getFieldValue('ATTR');
+    var code = varName + "." + attr;
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const requests_post = function (_, generator) {
+    generator.definitions_['import_urequests'] = "import urequests";
+    var dropdown_type = this.getFieldValue('TYPE');
+    var str = generator.valueToCode(this, 'URL', generator.ORDER_ATOMIC);
+    var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
+    var code = 'urequests.' + dropdown_type + '(' + str + ', data=' + data + ')';
+    return [code, generator.ORDER_ATOMIC];
+
+};
+
+export const educore_wifi_connect = function (_, generator) {
+    generator.definitions_['import_educore_wifi'] = "from educore import wifi";
+    var username = generator.valueToCode(this, 'WIFINAME', generator.ORDER_ATOMIC);
+    var password = generator.valueToCode(this, 'PASSWORD', generator.ORDER_ATOMIC);
+    var timeout = generator.valueToCode(this, 'TIMEOUT', generator.ORDER_ATOMIC);
+    var code = 'wifi.connect(ssid='+username+', psd='+password+', timeout='+timeout+')\n';
+    return code;
+}
+
+export const educore_mqtt_connect = function (_, generator) {
+    generator.definitions_['import_educore_mqttclient'] = "from educore import mqttclient";
+    var server = generator.valueToCode(this, 'SERVER', generator.ORDER_ATOMIC);
+    var port = generator.valueToCode(this, 'PORT', generator.ORDER_ATOMIC);
+    var client_id = generator.valueToCode(this, 'CLIENT_ID', generator.ORDER_ATOMIC);
+    var username = generator.valueToCode(this, 'USERNAME', generator.ORDER_ATOMIC);
+    var password = generator.valueToCode(this, 'PASSWORD', generator.ORDER_ATOMIC);
+    // var a = "'" + username.replace("'", "").replace("'", "") + "/" + project.replace("'", "").replace("'", "") + "/'"
+    // var code = 'MQTT_USR_PRJ = ' + a + '\n' + 'mqtt_client = mixiot.init_MQTT_client(' + server + ', ' + username + ', ' + password + ', MQTT_USR_PRJ)\n';
+    var code = 'mqttclient.connect(server='+server+', port='+port+', client_id='+client_id+', user='+username+', psd='+password+')\n'
+    return code;
+}
+
+export const educore_mqtt_subscribe_message = function (_, generator) {
+    generator.definitions_['import_educore_mqttclient'] = "from educore import mqttclient";
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var message = generator.valueToCode(this, 'MESSAGE', generator.ORDER_ATOMIC);
+    var code = 'mqttclient.'+message+'(' + topic + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_mqtt_topic_subscribe = function (_, generator) {
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var method = generator.valueToCode(this, 'METHOD', generator.ORDER_ATOMIC);
+    generator.definitions_['import_educore_mqttclient'] = "from educore import mqttclient";
+    // var code = 'mqtt_client.set_callback(' + topic + ',' + method + ', MQTT_USR_PRJ)\n';
+    // code += 'mqtt_client.subscribe(MQTT_USR_PRJ + ' + topic + ')\n';
+    var code = 'mqttclient.received(topic='+topic+', callback='+method+')\n';
+    return code;
+}
+
+export const educore_mqtt_topic_publish = function (_, generator) {
+    generator.definitions_['import_educore_mqttclient'] = "from educore import mqttclient";
+    var topic = generator.valueToCode(this, 'TOPIC', generator.ORDER_ATOMIC);
+    var msg = generator.valueToCode(this, 'MSG', generator.ORDER_ATOMIC);
+    var code = 'mqtt_client.publish(topic=' + topic + ', content=' + msg + ')\n';
+    return code;
+}
+
+export const educore_mqtt_connect_success = function (_, generator) {
+    generator.definitions_['import_educore_mqttclient'] = "from educore import mqttclient";
+    var code = 'mqtt_client.connescted()';
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/nova_g1.js

@@ -0,0 +1,29 @@
+export const get_potential_num = function (_, generator) {
+    generator.definitions_['from_nova_g1_import_ext_g1'] = 'from nova_g1 import ext_g1';
+    var code = 'ext_g1.varistor()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const nova_g1_motor = function (_, generator) {
+    generator.definitions_['from_nova_g1_import_ext_g1'] = 'from nova_g1 import ext_g1';
+    var wheel = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var v = this.getFieldValue('direction');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = "ext_g1.motor(" + wheel + ', "' + v + '", ' + speed + ")\n";
+    return code;
+}
+
+export const nova_g1_usb = function (_, generator) {
+    generator.definitions_['from_nova_g1_import_ext_g1'] = 'from nova_g1 import ext_g1';
+    var p = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var percent = generator.valueToCode(this, 'percent', generator.ORDER_ATOMIC);
+    var code = "ext_g1.usb_pwm(" + p + ', ' + percent + ")\n";
+    return code;
+}
+
+export const nova_g1_spk_en = function (_, generator) {
+    generator.definitions_['from_nova_g1_import_ext_g1'] = 'from nova_g1 import ext_g1';
+    var state = this.getFieldValue('state');
+    var code = "ext_g1.spk_en(" + state + ")\n";
+    return code;
+}

mixly/boards/default_src/micropython/generators/pe_g1.js

@@ -0,0 +1,67 @@
+export const pe_g1_use_i2c_init = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var iv = generator.valueToCode(this, 'I2CSUB', generator.ORDER_ATOMIC);
+    var code = v + ' = pe_g1.PE_G1(' + iv + ')\n';
+    return code;
+}
+
+export const pe_g1_battery_left = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = v + '.read_bat()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const pe_g1_dc_motor = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var s = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var wheel = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var v = this.getFieldValue('direction');
+    var speed = generator.valueToCode(this, 'speed', generator.ORDER_ATOMIC);
+    var code = s + ".motor(" + wheel + ', "' + v + '", ' + speed + ")\n";
+    return code;
+}
+
+export const pe_g1_dc_motor_speed = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var s = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var wheel = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var v = 'NC';
+    var code = s + ".motor(" + wheel + ', "' + v + '"' + ")\n";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const pe_g1_servo_set_angle = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    var code = v + '.servo180(' + dropdown_pin + ', ' + num + ')\n';
+    return code;
+}
+
+export const pe_g1_servo_set_speed = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var num = generator.valueToCode(this, 'NUM', generator.ORDER_ATOMIC);
+    var code = v + '.servo360(' + dropdown_pin + ', ' + num + ')\n';
+    return code;
+}
+
+export const pe_g1_servo_get_angle = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = v + '.servo180(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const pe_g1_servo_get_speed = function (_, generator) {
+    generator.definitions_['import_pe_g1'] = 'import pe_g1';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = v + '.servo360(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/pins.js

@@ -0,0 +1,30 @@
+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 espnow_channel = 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;

mixly/boards/default_src/micropython/generators/sensor.js

@@ -0,0 +1,405 @@
+import { sensor_LTR308 } from './sensor_onboard';
+
+export const sensor_mixgo_button_is_pressed = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var code = 'mixgo.' + btn + '.is_pressed()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//ok
+export const sensor_mixgo_button_was_pressed = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var code = 'mixgo.' + btn + '.was_pressed()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_button_get_presses = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var argument = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
+    var code = 'mixgo.' + btn + '.get_presses(' + argument + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_button_attachInterrupt = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var dropdown_btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var dropdown_mode = this.getFieldValue('mode');
+    var atta = generator.valueToCode(this, 'DO', generator.ORDER_ATOMIC);
+    var code = 'mixgo.' + dropdown_btn + '.irq' + '(handler=' + atta + ', trigger=' + dropdown_mode + ')\n'
+    return code;
+}
+
+//ok
+export const sensor_mixgo_extern_button_is_pressed = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = 'mixgo.Button(' + pin + ').is_pressed(' + dropdown_stat + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//ok
+export const sensor_mixgo_extern_button_was_pressed = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_stat = generator.valueToCode(this, 'STAT', generator.ORDER_ATOMIC);
+    var code = 'mixgo.Button(' + pin + ').was_pressed(' + dropdown_stat + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_extern_button_get_presses = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var argument = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
+    var code = 'mixgo.Button(' + pin + ').get_presses(' + argument + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_extern_button_attachInterrupt = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var dropdown_mode = this.getFieldValue('mode');
+    var atta = generator.valueToCode(this, 'DO', generator.ORDER_ATOMIC);
+    var code = 'mixgo.Button(' + pin + ').irq' + '(handler=' + atta + ', trigger=' + dropdown_mode + ')\n'
+    return code;
+}
+
+//ok
+export const sensor_mpu9250_attachGestureInterrupt = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_machine'] = 'import machine';
+    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';
+    generator.definitions_['import_machine'] = 'import machine';
+    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];
+}
+
+//ok
+export const sensor_mpu9250_get_acceleration = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_machine'] = 'import machine';
+    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';
+    // generator.definitions_['import_machine'] = 'import machine';
+    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';
+    generator.definitions_['import_machine'] = 'import machine';
+    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';
+    generator.definitions_['import_machine'] = 'import machine';
+    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_machine'] = 'import machine';
+    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';
+    generator.definitions_['import_machine'] = 'import machine';
+    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_distance_hrsc04 = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    generator.setups_['class_hrsc04'] =
+        'class HCSR04:\n' +
+        '    def __init__(self, tpin=pin15, epin=pin14, spin=pin13):\n' +
+        '        self.trigger_pin = tpin\n' +
+        '        self.echo_pin = epin\n' +
+        '        self.sclk_pin = spin\n' +
+        '\n' +
+        '    def distance_mm(self):\n' +
+        '        spi.init(baudrate=125000, sclk=self.sclk_pin,\n' +
+        '                 mosi=self.trigger_pin, miso=self.echo_pin)\n' +
+        '        pre = 0\n' +
+        '        post = 0\n' +
+        '        k = -1\n' +
+        '        length = 500\n' +
+        '        resp = bytearray(length)\n' +
+        '        resp[0] = 0xFF\n' +
+        '        spi.write_readinto(resp, resp)\n' +
+        '        # find first non zero value\n' +
+        '        try:\n' +
+        '            i, value = next((ind, v) for ind, v in enumerate(resp) if v)\n' +
+        '        except StopIteration:\n' +
+        '            i = -1\n' +
+        '        if i > 0:\n' +
+        '            pre = bin(value).count("1")\n' +
+        '            # find first non full high value afterwards\n' +
+        '            try:\n' +
+        '                k, value = next((ind, v)\n' +
+        '                                for ind, v in enumerate(resp[i:length - 2]) if resp[i + ind + 1] == 0)\n' +
+        '                post = bin(value).count("1") if k else 0\n' +
+        '                k = k + i\n' +
+        '            except StopIteration:\n' +
+        '                i = -1\n' +
+        '        dist= -1 if i < 0 else round((pre + (k - i) * 8. + post) * 8 * 0.172)\n' +
+        '        return dist\n' +
+        '\n' +
+        'sonar=HCSR04()\n'
+    return ['sonar.distance_mm() / 10.0', generator.ORDER_ATOMIC];
+}
+
+export const RTC_get_time = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "rtc")
+        generator.definitions_['import_mixgo_rtc'] = 'from mixgo import rtc';
+    var code = v + '.datetime()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const RTC_set_time = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var hour = generator.valueToCode(this, "hour", generator.ORDER_ASSIGNMENT);
+    var minute = generator.valueToCode(this, "minute", generator.ORDER_ASSIGNMENT);
+    var second = generator.valueToCode(this, "second", generator.ORDER_ASSIGNMENT);
+    generator.setups_['class_DS1307'] = generator.CLASS_DS1307_INIT;
+    var code = 'str(ds.Hour(' + hour + ')) + str(ds.Minute(' + minute + ')) + str(ds.Second(' + second + '))\n';
+    return code;
+}
+
+export const RTC_set_date = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var year = generator.valueToCode(this, "year", generator.ORDER_ASSIGNMENT);
+    var month = generator.valueToCode(this, "month", generator.ORDER_ASSIGNMENT);
+    var day = generator.valueToCode(this, "day", generator.ORDER_ASSIGNMENT);
+    generator.setups_['class_DS1307'] = generator.CLASS_DS1307_INIT;
+    var code = 'str(ds.Year(' + year + ')) + str(ds.Month(' + month + ')) + str(ds.Day(' + day + '))\n';
+    return code;
+}
+
+export const sensor_compass_reset = function (block, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_machine'] = 'import machine';
+    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 HCSR04 = function (_, generator) {
+    generator.definitions_['import_sonar'] = 'import sonar';
+    var dropdown_pin1 = generator.valueToCode(this, "PIN1", generator.ORDER_ASSIGNMENT);
+    var dropdown_pin2 = generator.valueToCode(this, "PIN2", generator.ORDER_ASSIGNMENT);
+    var code = 'sonar.Sonar(' + dropdown_pin1 + ', ' + dropdown_pin2 + ').checkdist()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_dht11 = function (_, generator) {
+    generator.definitions_['import_dhtx'] = 'import dhtx';
+    var sensor_type = this.getFieldValue('TYPE');
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var what = this.getFieldValue('WHAT');
+    var code = 'dhtx.get_dht_' + what + "('" + sensor_type + "', " + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_extern_light = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'mixgo.get_brightness(' + pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_extern_sound = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'mixgo.get_soundlevel(' + pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number1 = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_pin_pressed = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'button', generator.ORDER_ATOMIC);
+    var code = 'mixgo.' + pin + '.is_touched()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_extern_pin_near = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'mixgo.' + 'Infrared(' + pin + ')()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_pin_near = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var direction = this.getFieldValue('direction');
+    var code = 'mixgo.' + 'infrared_' + direction + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const RTC_set_datetime = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var year = generator.valueToCode(this, "year", generator.ORDER_ASSIGNMENT);
+    var month = generator.valueToCode(this, "month", generator.ORDER_ASSIGNMENT);
+    var day = generator.valueToCode(this, "day", generator.ORDER_ASSIGNMENT);
+    var hour = generator.valueToCode(this, "hour", generator.ORDER_ASSIGNMENT);
+    var minute = generator.valueToCode(this, "minute", generator.ORDER_ASSIGNMENT);
+    var second = generator.valueToCode(this, "second", generator.ORDER_ASSIGNMENT);
+    var week = generator.valueToCode(this, "weekday", generator.ORDER_ASSIGNMENT);
+    var millisecond = generator.valueToCode(this, "millisecond", generator.ORDER_ASSIGNMENT);
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    if (v == "rtc")
+        generator.definitions_['import_mixgo_rtc'] = 'from mixgo import rtc';
+    var code = v + '.datetime((' + year + ', ' + month + ', ' + day + ', ' + week + ', ' + hour + ', ' + minute + ', ' + second + ', ' + millisecond + '))\n';
+    return code;
+}
+
+export const sensor_rtc_init = function (_, generator) {
+    var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    generator.definitions_['import_machine'] = 'import machine';
+    var code = v + ' = machine.RTC()\n';
+    return code;
+}
+
+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');
+    generator.definitions_['import_machine'] = 'import machine';
+    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_machine'] = 'import machine';
+    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_machine'] = 'import machine';
+    generator.definitions_['import_sht20'] = 'import sht20';
+    var code = v + '.' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_ds18x20 = function (_, generator) {
+    generator.definitions_['import_ds18x20x'] = 'import ds18x20x';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'ds18x20x.get_ds18x20_temperature(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_lm35 = function (_, generator) {
+    generator.definitions_['import_lm35'] = 'import lm35';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'lm35.get_LM35_temperature(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_button_is_pressed = sensor_mixgo_button_is_pressed;
+export const sensor_button_was_pressed = sensor_mixgo_button_was_pressed;
+export const sensor_button_get_presses = sensor_mixgo_button_get_presses;
+export const sensor_pin_pressed = sensor_mixgo_pin_pressed;
+export const sensor_pin_near = sensor_mixgo_pin_near;
+export const sensor_mixgo_light = sensor_LTR308;
+export const sensor_light = sensor_mixgo_light;
+// export const sensor_get_acceleration = sensor_mixgo_get_acceleration;
+export const dht11 = sensor_dht11;

mixly/boards/default_src/micropython/generators/sensor_onboard.js

@@ -0,0 +1,978 @@
+import { Boards } from 'mixly';
+import { sensor_dht11 } from './sensor_extern.js';
+
+export const sensor_mixgo_button_is_pressed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var code = version + '.' + btn + '.is_pressed()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//ok
+export const sensor_mixgo_button_was_pressed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var code = version + '.' + btn + '.was_pressed()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_button_get_presses = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var argument = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
+    var code = version + '.' + btn + '.get_presses(' + argument + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_button_attachInterrupt = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var dropdown_btn = generator.valueToCode(this, 'btn', generator.ORDER_ATOMIC);
+    var dropdown_mode = this.getFieldValue('mode');
+    var atta = generator.valueToCode(this, 'DO', generator.ORDER_ATOMIC);
+    var code = version + '.' + dropdown_btn + '.irq' + '(handler=' + atta + ', trigger=' + dropdown_mode + ')\n'
+    return code;
+}
+
+//ok
+export const sensor_mixgocar42_button_is_pressed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var code = version + '.' + 'button.is_pressed()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//ok
+export const sensor_mixgocar42_button_was_pressed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var code = version + '.' + 'button.was_pressed()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgocar42_button_get_presses = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var argument = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
+    var code = version + '.' + 'button.get_presses(' + argument + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgocar42_button_attachInterrupt = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var version = Boards.getSelectedBoardKey().split(':')[2]
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var dropdown_mode = this.getFieldValue('mode');
+    var atta = generator.valueToCode(this, 'DO', generator.ORDER_ATOMIC);
+    var code = version + '.' + 'button.irq' + '(handler=' + atta + ', trigger=' + dropdown_mode + ')\n'
+    return code;
+}
+
+export const HCSR04 = function (_, generator) {
+    generator.definitions_['import_sonar'] = 'import sonar';
+    var dropdown_pin1 = generator.valueToCode(this, "PIN1", generator.ORDER_ASSIGNMENT);
+    var dropdown_pin2 = generator.valueToCode(this, "PIN2", generator.ORDER_ASSIGNMENT);
+    var code = 'sonar.Sonar(' + dropdown_pin1 + ', ' + dropdown_pin2 + ').checkdist()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number1 = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number2 = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number3 = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number4 = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number5 = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number6 = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const number7 = function (_, generator) {
+    var code = this.getFieldValue('op');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_pin_near_single = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_als'] = "from " + version + " import onboard_als";
+    var code = 'onboard_als.ps_nl()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_pin_near_double = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var direction = this.getFieldValue('direction');
+    var code = version + '.' + 'infrared_' + direction + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_pin_near = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_als'] = 'from ' + version + ' import onboard_als';
+    var code = 'onboard_als.ps()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_nova_pin_near = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var direction = this.getFieldValue('direction');
+    generator.definitions_['import_' + version + '_' + direction] = 'from ' + version + ' import onboard_als_' + direction;
+    var code = 'onboard_als_' + direction + '.ps_nl()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_LTR308 = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_als'] = 'from ' + version + ' import onboard_als';
+    var code = 'onboard_als.als()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_sant_color = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_als'] = 'from ' + version + ' import onboard_als';
+    var code = 'onboard_als.color()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_nova_LTR308 = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var direction = this.getFieldValue('direction');
+    generator.definitions_['import_' + version + '_' + direction] = 'from ' + version + ' import onboard_als_' + direction;
+    var code = 'onboard_als_' + direction + '.als_vis()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_ds18x20 = function (_, generator) {
+    generator.definitions_['import_ds18x20x'] = 'import ds18x20x';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'ds18x20x.get_ds18x20_temperature(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_lm35 = function (_, generator) {
+    generator.definitions_['import_lm35'] = 'import lm35';
+    var dropdown_pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'lm35.get_LM35_temperature(' + dropdown_pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_LTR308 = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == "mixgo") {
+        generator.definitions_['import_mixgo'] = 'import mixgo';
+        return ['mixgo.get_brightness()', generator.ORDER_ATOMIC];
+    } else if (version == "mixgo_ce") {
+        generator.definitions_['import_mixgo_ce'] = 'import mixgo_ce';
+        return ['mixgo_ce.get_brightness()', generator.ORDER_ATOMIC];
+    } else if (version == "mpython") {
+        generator.definitions_['import_mpython_onboard_light'] = 'from mpython import onboard_light';
+        return ['onboard_light.brightness()', generator.ORDER_ATOMIC];
+    }
+    generator.definitions_['import_' + version + '_onboard_als'] = "from " + version + " import onboard_als";
+    var code = 'onboard_als.als_vis()';
+    return [code, generator.ORDER_ATOMIC];
+    // else{return ['', generator.ORDER_ATOMIC];}
+}
+
+export const sensor_sound = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixbot') {
+        generator.definitions_['import_' + version + '_sound'] = 'from ' + version + ' import sound';
+        var code = 'sound.loudness()';
+    } else if (version == 'mixgo_zero') {
+        generator.definitions_['import_mixgo_zero_voice_sound_level'] = "from mixgo_zero_voice import sound_level";
+        var code = 'sound_level()';
+    } else if (version == 'mixgo_nova') {
+        generator.definitions_['import_mixgo_nova_voice_sound_level'] = "from mixgo_nova_voice import sound_level";
+        var code = 'sound_level()';
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_mixgo_soar_voice_sound_level'] = "from mixgo_soar_voice import sound_level";
+        var code = 'sound_level()';
+    }else if (version == "mixgo") {
+        generator.definitions_['import_mixgo'] = 'import mixgo';
+        return ['mixgo.get_soundlevel()', generator.ORDER_ATOMIC];
+    } else if (version == "mpython") {
+        generator.definitions_['import_mpython_onboard_sound'] = 'from mpython import onboard_sound';
+        return ['onboard_sound.soundlevel()', generator.ORDER_ATOMIC];
+    } else if (version == "mixgo_mini") {
+        generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+        var code = 'onboard_bot.soundlevel()';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_sound'] = 'from ' + version + ' import onboard_sound';
+        var code = 'onboard_sound.read()';
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+// export const sensor_mixgo_nova_sound = function (_, generator) {
+//     var version = Boards.getSelectedBoardKey().split(':')[2]
+//     return [code, generator.ORDER_ATOMIC];
+// }
+
+export const sensor_hp203 = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var key = this.getFieldValue('key');
+    if (version == "mixgo_mini") {
+        generator.definitions_['import_mixgo_mini_onboard_i2c'] = 'from mixgo_mini import onboard_i2c';
+        generator.definitions_['import_spl06_001'] = 'import spl06_001';
+        generator.definitions_['import_onboard_bps'] = 'onboard_bps = spl06_001.SPL06(onboard_i2c)';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_bps'] = "from " + version + " import onboard_bps";
+    }
+    var code = 'onboard_bps.' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_aht11 = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var key = this.getFieldValue('key');
+    if (version == 'mixgo_nova' || version == 'mixgo_zero') {
+        generator.definitions_['import_' + version + '_onboard_ths'] = "from " + version + " import onboard_ths";
+    } else if (version == 'mixgo_mini') {
+        generator.definitions_['import_mixgo_mini_onboard_i2c'] = 'from mixgo_mini import onboard_i2c';
+        generator.definitions_['import_shtc3'] = 'import shtc3';
+        generator.definitions_['import_onboard_ths'] = 'onboard_ths = shtc3.SHTC3(onboard_i2c)';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_ths'] = "from " + version + " import onboard_ths";
+    }
+    var code = 'onboard_ths.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_get_temperature = function (_, generator) {
+    generator.definitions_['import_feiyi_onboard_acc'] = 'from feiyi import onboard_acc';
+    return ['onboard_acc.temperature()', generator.ORDER_ATOMIC];
+}
+
+export const rfid_readid = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var moduleName = version;
+    var objName = 'onboard_rfid';
+    if (version === 'mixgo_mini') {
+        moduleName = 'mini_gx';
+        objName = 'ext_rfid';
+    } else if (version === 'mixgo_me') {
+        moduleName = 'me_g1';
+        objName = 'ext_rc522';
+    }else if (version === 'mixgo_sant'){
+        moduleName = 'sant_gx';
+        objName = 'ext_rfid';
+    }
+    generator.definitions_[`import_${moduleName}_${objName}`] = `from ${moduleName} import ${objName}`;
+    var code = `${objName}.read_card(0, x="id")`;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const rfid_readcontent = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var sector = generator.valueToCode(this, 'SECTOR', generator.ORDER_ATOMIC);
+    var moduleName = version;
+    var objName = 'onboard_rfid';
+    if (version === 'mixgo_mini') {
+        moduleName = 'mini_gx';
+        objName = 'ext_rfid';
+    } else if (version === 'mixgo_me') {
+        moduleName = 'me_g1';
+        objName = 'ext_rc522';
+    }else if (version === 'mixgo_sant'){
+        moduleName = 'sant_gx';
+        objName = 'ext_rfid';
+    }
+    generator.definitions_[`import_${moduleName}_${objName}`] = `from ${moduleName} import ${objName}`;
+    var code = `${objName}.read_card(${sector}, x="content")`;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const rfid_write = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var sector = generator.valueToCode(this, 'SECTOR', generator.ORDER_ATOMIC);
+    var cnt = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC);
+    var moduleName = version;
+    var objName = 'onboard_rfid';
+    if (version === 'mixgo_mini') {
+        moduleName = 'mini_gx';
+        objName = 'ext_rfid';
+    } else if (version === 'mixgo_me') {
+        moduleName = 'me_g1';
+        objName = 'ext_rc522';
+    }else if (version === 'mixgo_sant'){
+        moduleName = 'sant_gx';
+        objName = 'ext_rfid';
+    }
+    generator.definitions_[`import_${moduleName}_${objName}`] = `from ${moduleName} import ${objName}`;
+    var code = `${objName}.write_card(${cnt}, ${sector})\n`;
+    return code;
+}
+
+export const rfid_write_return = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var sector = generator.valueToCode(this, 'SECTOR', generator.ORDER_ATOMIC);
+    var cnt = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC);
+    var moduleName = version;
+    var objName = 'onboard_rfid';
+    if (version === 'mixgo_mini') {
+        moduleName = 'mini_gx';
+        objName = 'ext_rfid';
+    } else if (version === 'mixgo_me') {
+        moduleName = 'me_g1';
+        objName = 'ext_rc522';
+    }else if (version === 'mixgo_sant'){
+        moduleName = 'sant_gx';
+        objName = 'ext_rfid';
+    }
+    generator.definitions_[`import_${moduleName}_${objName}`] = `from ${moduleName} import ${objName}`;
+    var code = `${objName}.write_card(${cnt}, ${sector})`;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const rfid_status = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var key = this.getFieldValue('key');
+    var moduleName = version;
+    var objName = 'onboard_rfid';
+    if (version === 'mixgo_mini') {
+        moduleName = 'mini_gx';
+        objName = 'ext_rfid';
+    } else if (version === 'mixgo_me') {
+        moduleName = 'me_g1';
+        objName = 'ext_rc522';
+    } else if (version === 'mixgo_sant'){
+        moduleName = 'sant_gx';
+        objName = 'ext_rfid';
+    }
+    generator.definitions_[`import_${moduleName}_${objName}`] = `from ${moduleName} import ${objName}`;
+    var code = `${objName}.scan_card() == ${key}`;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_get_acceleration = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var key = this.getFieldValue('key');
+    if (key == 'strength') {
+        if (version == 'mixbot') {
+            generator.definitions_['import_' + version + '_acc_gyr'] = 'from ' + version + ' import acc_gyr';
+            var code = 'acc_gyr.strength()';
+        } else if(version == 'mixgo_soar'){
+            generator.definitions_['import_' + version + '_onboard_imu'] = "from " + version + " import onboard_imu";
+            var code = 'onboard_imu.strength()';
+        } else {
+            generator.definitions_['import_' + version + '_onboard_acc'] = "from " + version + " import onboard_acc";
+            var code = 'onboard_acc.strength()';
+        }
+        return [code, generator.ORDER_ATOMIC];
+    }
+    if (version == 'mixbot') {
+        generator.definitions_['import_' + version + '_acc_gyr'] = 'from ' + version + ' import acc_gyr';
+        var code = 'acc_gyr.accelerometer()' + key;
+    } else if (version == 'mpython') {
+        generator.definitions_['import_mpython_motion'] = 'from mpython import motion';
+        var code = 'motion.accelerometer()' + key;
+    } else if (version == 'mixgo_soar') {
+        generator.definitions_['import_' + version + '_onboard_imu'] = "from " + version + " import onboard_imu";
+        var code = 'onboard_imu.acceleration()'+ key;
+    }else {
+        generator.definitions_['import_' + version + '_onboard_acc'] = "from " + version + " import onboard_acc";
+        var code = 'onboard_acc.acceleration()' + key;
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_eulerangles = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_acc'] = "from " + version + " import onboard_acc";
+    var angle = this.getFieldValue('angle');
+    var code = 'onboard_acc.eulerangles()' + angle;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpu9250_gesture = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_machine'] = 'import machine';
+    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];
+}
+
+//ok
+export const sensor_mpu9250_get_acceleration = function (_, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_machine'] = 'import machine';
+    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_mixgoce_pin_pressed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var pin = generator.valueToCode(this, 'button', generator.ORDER_ATOMIC);
+    if (version === 'mixgo_mini' || version === 'mixgo_sant' || version === 'mixgo_soar') {
+        generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+        var code = 'onboard_bot.touched(' + pin + ')';
+    } else {
+        generator.definitions_['import_' + version] = 'import ' + version;
+        var code = version + '.touched(' + pin + ')';
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_touch_slide = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version === 'mixgo_mini' || version === 'mixgo_sant' || version === 'mixgo_soar' || version === 'mixgo_sowl') {
+        generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+        var code = 'onboard_bot.touch_slide()';
+    } else {
+        generator.definitions_['import_' + version] = 'import ' + version;
+        var code = version + '.touch_slide(3, 4)';
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_pin_pressed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version] = 'import ' + version;
+    var pin = generator.valueToCode(this, 'button', generator.ORDER_ATOMIC);
+    var code = version + '.' + pin + '.is_touched()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpython_pin_pressed = function (_, generator) {
+    generator.definitions_['import_mpython'] = 'import mpython';
+    var pin = generator.valueToCode(this, 'button', generator.ORDER_ATOMIC);
+    var code = 'mpython.touch_' + pin + '.is_touched()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_adxl345_get_acceleration = function (_, generator) {
+    generator.definitions_['import_adxl345'] = 'import adxl345';
+    // generator.definitions_['import_machine'] = 'import machine';
+    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';
+    generator.definitions_['import_machine'] = 'import machine';
+    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';
+    generator.definitions_['import_machine'] = 'import machine';
+    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_machine'] = 'import machine';
+    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';
+    generator.definitions_['import_machine'] = 'import machine';
+    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 (block, generator) {
+    generator.definitions_['import_mpu9250'] = 'import mpu9250';
+    generator.definitions_['import_machine'] = 'import machine';
+    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_onboard_mpu9250_gesture = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var gesture = this.getFieldValue('gesture');
+    generator.definitions_['import_mixgo_onboard_mpu'] = 'from mixgo import onboard_mpu';
+    var code = 'onboard_mpu.mpu9250_is_gesture("' + gesture + '")';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_onboard_mpu9250_get_acceleration = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_mixgo_onboard_mpu'] = 'from mixgo import onboard_mpu';
+    var code = 'onboard_mpu.mpu9250_get_' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_onboard_mpu9250_get_magnetic = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_mixgo_onboard_mpu'] = 'from mixgo import onboard_mpu';
+    var code = 'onboard_mpu.mpu9250_magnetic_' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_onboard_mpu9250_get_gyro = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_mixgo_onboard_mpu'] = 'from mixgo import onboard_mpu';
+    var code = 'onboard_mpu.mpu9250_gyro_' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_onboard_mpu9250_calibrate_compass = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_mixgo_onboard_compass'] = 'from mixgo import onboard_compass';
+    return '' + 'onboard_compass.calibrate()\n';
+}
+
+export const sensor_onboard_mpu9250_temperature = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_mixgo_onboard_mpu'] = 'from mixgo import onboard_mpu';
+    return ['onboard_mpu.mpu9250_get_temperature()', generator.ORDER_ATOMIC];
+}
+
+export const sensor_onboard_mpu9250_field_strength = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_mixgo_onboard_compass'] = 'from mixgo import onboard_compass';
+    var compass = this.getFieldValue('compass');
+    var a;
+    if (compass == 'strength') {
+        a = 'onboard_compass.get_field_strength()';
+    } else if (compass == 'heading') {
+        a = 'onboard_compass.heading()';
+    }
+    return [a, generator.ORDER_ATOMIC];
+}
+
+export const sensor_onboard_compass_reset = function (block, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    generator.definitions_['import_mixgo_onboard_compass'] = 'from mixgo import onboard_compass';
+    return '' + 'onboard_compass.reset_calibrate()\n';
+}
+
+export const onboard_RTC_set_datetime = function (_, generator) {
+    generator.definitions_['import_rtctime'] = "import rtctime";
+    var year = generator.valueToCode(this, "year", generator.ORDER_ASSIGNMENT);
+    var month = generator.valueToCode(this, "month", generator.ORDER_ASSIGNMENT);
+    var day = generator.valueToCode(this, "day", generator.ORDER_ASSIGNMENT);
+    var hour = generator.valueToCode(this, "hour", generator.ORDER_ASSIGNMENT);
+    var minute = generator.valueToCode(this, "minute", generator.ORDER_ASSIGNMENT);
+    var second = generator.valueToCode(this, "second", generator.ORDER_ASSIGNMENT);
+    var code = 'rtctime.settime((' + year + ', ' + month + ', ' + day + ', ' + hour + ', ' + minute + ', ' + second + ', 0, 0))\n';
+    return code;
+}
+
+export const onboard_RTC_settime_string = function (_, generator) {
+    var cnt = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC);
+    generator.definitions_['import_rtctime'] = "import rtctime";
+    var code = 'rtctime.settime(' + cnt + ')\n';
+    return code;
+}
+
+export const onboard_RTC_get_time = function (_, generator) {
+    generator.definitions_['import_time'] = 'import time';
+    var code = 'time.localtime()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const onboard_RTC_get_timestamp = function (_, generator) {
+    generator.definitions_['import_time'] = 'import time';
+    var time = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC);
+    var code = 'time.mktime(' + time + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const onboard_RTC_timestamp_totuple = function (_, generator) {
+    generator.definitions_['import_time'] = 'import time';
+    var ts = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
+    var code = 'time.localtime(' + ts + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const onboard_RTC_get_time_str = function (_, generator) {
+    generator.definitions_['import_rtctime'] = 'import rtctime';
+    var code = 'rtctime.strtime()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const onboard_RTC_get_timetuple_to_str = function (_, generator) {
+    generator.definitions_['import_rtctime'] = 'import rtctime';
+    var ct = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC);
+    var code = 'rtctime.strtime(' + ct + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//mixgo_cc onboard_sensor generators:
+
+export const sensor_mixgo_cc_mmc5603_get_magnetic = function (_, generator) {
+    var key = this.getFieldValue('key');
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mpython') {
+        generator.definitions_['import_mpython_magnetic'] = 'from mpython import magnetic';
+        if (key == 'all') {
+            var code = 'magnetic.getstrength()';
+        } else {
+            var code = 'magnetic.getdata()' + key;
+        }
+    } else if (version == 'mixgo_mini') {
+        generator.definitions_['import_mixgo_mini_onboard_i2c'] = 'from mixgo_mini import onboard_i2c';
+        generator.definitions_['import_mmc5603'] = 'import mmc5603';
+        generator.definitions_['import_onboard_mgs'] = 'onboard_mgs = mmc5603.MMC5603(onboard_i2c)';
+        if (key == 'all') {
+            var code = 'onboard_mgs.getstrength()';
+        } else {
+            var code = 'onboard_mgs.getdata()' + key;
+        }
+    } else {
+        generator.definitions_['import_' + version + '_onboard_mgs'] = "from " + version + " import onboard_mgs";
+        if (key == 'all') {
+            var code = 'onboard_mgs.getstrength()';
+        } else {
+            var code = 'onboard_mgs.getdata()' + key;
+        }
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_cc_mmc5603_get_angle = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mpython') {
+        generator.definitions_['import_mpython_magnetic'] = 'from mpython import magnetic';
+        var code = 'magnetic.getangle()';
+    } else if (version == 'mixgo_mini') {
+        generator.definitions_['import_mixgo_mini_onboard_i2c'] = 'from mixgo_mini import onboard_i2c';
+        generator.definitions_['import_mmc5603'] = 'import mmc5603';
+        generator.definitions_['import_onboard_mgs'] = 'onboard_mgs = mmc5603.MMC5603(onboard_i2c)';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_mgs'] = "from " + version + " import onboard_mgs";
+    }
+    var code = 'onboard_mgs.getangle()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgo_cc_mmc5603_calibrate_compass = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mixgo_mini_onboard_i2c'] = 'from mixgo_mini import onboard_i2c';
+        generator.definitions_['import_mmc5603'] = 'import mmc5603';
+        generator.definitions_['import_onboard_mgs'] = 'onboard_mgs = mmc5603.MMC5603(onboard_i2c)';
+    } else {
+        generator.definitions_['import_' + version + '_onboard_mgs'] = "from " + version + " import onboard_mgs";
+    }
+    var code = 'onboard_mgs.calibrate()\n';
+    return code;
+}
+
+//mixgo_me onboard_sensor generators:
+
+export const sensor_mixgome_temperature = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'mixgo_mini') {
+        generator.definitions_['import_mixgo_mini_onboard_temperature'] = 'from mixgo_mini import onboard_temperature';
+        var code = 'onboard_temperature()';
+    } else {
+        generator.definitions_['import_mixgo_me_onboard_acc'] = "from mixgo_me import onboard_acc";
+        var code = 'onboard_acc.temperature()';
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//mixgo_ce onboard_sensor generators:
+export const sensor_mixgoce_temperature = function (_, generator) {
+    generator.definitions_['import_mixgo_ce'] = "import mixgo_ce";
+    var code = 'mixgo_ce.get_temperature()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//mpython onboard_sensor:
+
+export const sensor_mpython_qmi8658_get_gyro = function (_, generator) {
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_mpython_motion'] = 'from mpython import motion';
+    var code = 'motion.gyroscope()' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mpython_qmi8658_temperature = function (_, generator) {
+    generator.definitions_['import_mpython_motion'] = 'from mpython import motion';
+    return ['motion.temperature()', generator.ORDER_ATOMIC];
+}
+
+export const sensor_rm_pin_near_double = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var direction = this.getFieldValue('direction');
+    generator.definitions_['import_' + version + '_adc' + direction] = 'from ' + version + ' import adc' + direction;
+    var code = 'adc' + direction + '.read()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_rm_battery_left = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    if (version == 'feiyi') {
+        generator.definitions_['import_feiyi_onboard_bot51'] = 'from feiyi import onboard_bot51';
+        var code = 'onboard_bot51.read_bat()';
+        return [code, generator.ORDER_ATOMIC];
+    }
+    generator.definitions_['import_' + version + '_battery'] = 'from ' + version + ' import battery';
+    var code = 'battery.voltage()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_rm_acc = function (_, generator) {
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_rm_e1_gyro'] = 'from rm_e1 import gyro';
+    var code = 'gyro.acceleration()' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//car4.2
+export const sensor_mixgocar_pin_near_line = function (_, generator) {
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_mixgocar_c3_onboard_info'] = 'from mixgocar_c3 import onboard_info';
+    var code = 'onboard_info.patrol()' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgocar_pin_near = function (_, generator) {
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_mixgocar_c3_onboard_info'] = 'from mixgocar_c3 import onboard_info';
+    var code = 'onboard_info.obstacle()' + key;
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixgocar_pin_near_state_change = function (_, generator) {
+    var key = this.getFieldValue('key');
+    generator.definitions_['import_mixgocar_c3_onboard_info'] = 'from mixgocar_c3 import onboard_info';
+    var code = 'onboard_info.ir_mode(onboard_info.' + key + ')\n';
+    return code;
+}
+
+export const sensor_mixgocar_battery_left = function (_, generator) {
+    generator.definitions_['import_mixgocar_c3_onboard_info'] = 'from mixgocar_c3 import onboard_info';
+    var code = 'onboard_info.read_bat()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+//mixbot onboard_sensor below:
+
+export const sensor_mixbot_patrol_calibrate = function (_, generator) {
+    var key = this.getFieldValue('key');
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_patrol'] = 'from ' + version + ' import patrol';
+    var code = 'patrol.correct(patrol.CORRECTING_' + key + ')\n';
+    return code;
+}
+
+export const sensor_mixbot_patrol_value = function (_, generator) {
+    var key = this.getFieldValue('key');
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_patrol'] = 'from ' + version + ' import patrol';
+    var code = 'patrol.getdata()' + key + '';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixbot_temperature = function (_, generator) {
+    generator.definitions_['import_mixbot_acc_gyr'] = "from mixbot import acc_gyr";
+    var code = 'acc_gyr.temperature()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_mixbot_get_gyro = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    var key = this.getFieldValue('key');
+    if(version == 'mixgo_soar'){
+        generator.definitions_['import_' + version + '_onboard_imu'] = "from " + version + " import onboard_imu";
+        var code = 'onboard_imu.gyroscope()' +key ;
+    }else{
+        generator.definitions_['import_mixbot_acc_gyr'] = "from mixbot import acc_gyr";
+        var code = 'acc_gyr.gyroscope()' + key;
+    }
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_bitbot_ALS = function (_, generator) {
+    generator.definitions_['import_feiyi_onboard_bot51'] = 'from feiyi import onboard_bot51';
+    var mode = generator.valueToCode(this, 'mode', generator.ORDER_ATOMIC);
+    var code = 'onboard_bot51.' + 'read_als(' + mode + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const bitbot_als_num = function (_, generator) {
+    var code = this.getFieldValue('PIN');
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_button_is_pressed = sensor_mixgo_button_is_pressed;
+export const sensor_button_was_pressed = sensor_mixgo_button_was_pressed;
+export const sensor_button_get_presses = sensor_mixgo_button_get_presses;
+export const sensor_pin_pressed = sensor_mixgo_pin_pressed;
+export const sensor_pin_near = sensor_mixgo_pin_near;
+export const sensor_mixgo_light = sensor_LTR308;
+export const sensor_light = sensor_mixgo_light;
+export const dht11 = sensor_dht11;
+
+//educore onboard_sensor
+export const educore_voice_sensor = function (_, generator) {
+    generator.definitions_['import_educore_sound'] = 'from educore import sound';
+    var code = "sound()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_read = function (_, generator) {
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + ".read()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_light_sensor = function (_, generator) {
+    generator.definitions_['import_educore_light'] = 'from educore import light';
+    var code = "light()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_gyroscope_sensor = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_accelerometer'] = 'from ' + version + ' import accelerometer';
+    var code = "accelerometer()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_gyroscope_sensor_read = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_accelerometer'] = 'from ' + version + ' import accelerometer';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + "." + key + "()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_gyroscope_sensor_shake = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_accelerometer'] = 'from ' + version + ' import accelerometer';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + ".shake()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_button_sensor = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_button'] = 'from ' + version + ' import button';
+    var btn = this.getFieldValue('btn');
+    var code = 'button(button.' + btn + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_button_was_pressed = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_button'] = 'from ' + version + ' import button';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + '.status()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_rfid_sensor = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_rfid'] = 'from ' + version + ' import rfid';
+    var pin = generator.valueToCode(this, 'PIN', generator.ORDER_ATOMIC);
+    var code = 'rfid(' + pin + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_rfid_sensor_scan = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_rfid'] = 'from ' + version + ' import rfid';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var code = sub + '.scanning()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const educore_rfid_sensor_scan_data = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_rfid'] = 'from ' + version + ' import rfid';
+    var sub = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
+    var key = this.getFieldValue('key');
+    var code = sub + '.' + key + '()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const sensor_get_the_coprocessor_version = function (_, generator) {
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var code = 'onboard_bot.version()';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const simulated_light_sensor = function (_, generator){
+    var version = Boards.getSelectedBoardKey().split(':')[2];
+    generator.definitions_['import_' + version + '_onboard_bot'] = 'from ' + version + ' import onboard_bot';
+    var key = this.getFieldValue('key');
+    var code = 'onboard_bot.brightness('+ key + ')';
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/serial.js

@@ -0,0 +1,123 @@
+export const serial_print = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    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_print_byte = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_uart = this.getFieldValue('mode');
+    var content = generator.valueToCode(this, 'CONTENT', generator.ORDER_ATOMIC) || '""'
+    var code = "uart" + dropdown_uart + ".write(" + content + ")\n";
+    return code;
+}
+
+export const serial_println = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    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_['import_machine'] = 'import machine';
+    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_['import_machine'] = 'import machine';
+    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_['import_machine'] = 'import machine';
+    var dropdown_uart = this.getFieldValue('mode');
+    var code = "uart" + dropdown_uart + ".readline()";
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const serial_softserial = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var dropdown_uart = this.getFieldValue('mode')
+    var baudrate = this.getFieldValue('baudrate');
+    return "uart" + dropdown_uart + "=machine.UART(" + dropdown_uart + ", " + baudrate + ")\n";
+}
+
+export const serial_softserial_new = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var rx = generator.valueToCode(this, 'RX', generator.ORDER_ATOMIC);
+    var tx = generator.valueToCode(this, 'TX', generator.ORDER_ATOMIC);
+    var dropdown_uart = this.getFieldValue('mode')
+    var baudrate = this.getFieldValue('baudrate');
+    return "uart" + dropdown_uart + "=machine.UART(" + dropdown_uart + ", tx=" + tx + ", rx=" + rx + ", baudrate=" + baudrate + ")\n";
+}
+
+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) {
+    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) {
+    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_ai = function (_, generator) {
+    generator.definitions_['import_uart_com'] = 'import uart_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 = "uart_com.send(uart" + dropdown_uart + ", " + content + ", repeat=" + dropdown_stat + ")\n";
+    return code;
+}
+
+export const serial_read_from_ai = function (_, generator) {
+    generator.definitions_['import_uart_com'] = 'import uart_com';
+    var dropdown_uart = this.getFieldValue('mode');
+    var code = "uart_com.recv(uart" + dropdown_uart + ")";
+    return [code, generator.ORDER_ATOMIC];
+}

mixly/boards/default_src/micropython/generators/system.js

@@ -0,0 +1,204 @@
+import { Profile } from 'mixly';
+
+export const system_run_in_background = function (_, generator) {
+    var branch = generator.statementToCode(this, 'do');
+    return 'control.inBackground(() => {\n' + branch + '})\n';
+}
+
+export const system_reset = function () {
+    return 'control.reset()\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 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 controls_delay_new = 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 timer = function (_, generator) {
+    generator.definitions_['import_mixgo'] = 'import mixgo';
+    var v = generator.valueToCode(this, "VAR", generator.ORDER_NONE) || "None";
+    var period = generator.valueToCode(this, "period", generator.ORDER_NONE) || "0";
+    var mode = generator.valueToCode(this, "mode", generator.ORDER_NONE) || "None";
+    var callback = generator.valueToCode(this, "callback", generator.ORDER_NONE) || "None";
+    // var callback = generator.valueToCode(this, "callback", generator.ORDER_NONE) || "None";
+    var code = v + ".init(period=" + period + ", mode=Timer." + mode + ", callback=" + callback + ")\n";
+    return code;
+}
+
+
+export const set_system_timer = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var v = generator.valueToCode(this, "VAR", generator.ORDER_NONE) || "None";
+    var i = generator.valueToCode(this, "PIN", generator.ORDER_NONE) || "None";
+    var period = generator.valueToCode(this, "period", generator.ORDER_NONE) || "0";
+    var mode = this.getFieldValue('mode');
+    var callback = generator.valueToCode(this, "callback", generator.ORDER_NONE) || "None";
+    var code = v + " = machine.Timer("+ i +", period=" + period + ", mode=machine.Timer." + mode + ", 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_['import_machine'] = 'import machine';
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_NONE) || 'None';
+    var period = generator.valueToCode(this, 'period', generator.ORDER_NONE) || '0';
+    var mode = this.getFieldValue('mode');
+    var callback = generator.valueToCode(this, 'callback', generator.ORDER_NONE) || 'None';
+    var code = `${v}.init(period=${period}, mode=machine.Timer.${mode}, callback=${callback})\n`;
+    return code;
+}
+
+export const system_timer_deinit = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var v = generator.valueToCode(this, 'VAR', generator.ORDER_NONE) || 'None';
+    var code = `${v}.deinit()\n`;
+    return code;
+}
+
+export const system_wdt_init = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var period = generator.valueToCode(this, "period", generator.ORDER_NONE) || "0";
+    var code = 'wdt = machine.WDT(timeout= ' + period + ')\n';
+    return code;
+}
+
+export const system_wdt_feed = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var code = 'wdt.feed()\n';
+    return code;
+}
+
+export const system_machine_reset = function (_, generator) {
+    generator.definitions_['import_machine'] = 'import machine';
+    var code = 'machine.reset()\n';
+    return code;
+}
+
+export const system_bitbot_shutdown = function (_, generator) {
+    generator.definitions_['import_bitbot_onboard_bot51'] = 'from bitbot import onboard_bot51';
+    var code = 'onboard_bot51.shutdown()\n';
+    return code;
+}
+
+export const Timer_init = system_timer_init;
+export const system_timer = system_timer_init;
+export const timer2 = system_timer_init;
+export const time_ticks_diff = system_ticks_diff;
+export const base_delay = controls_delay;

mixly/boards/default_src/micropython/generators/weather.js

@@ -0,0 +1,160 @@
+export const WEATHER_NOW = function (_, generator) {
+    generator.definitions_['import_seniverse_api'] = "import seniverse_api";
+    var dropdown_mode = this.getFieldValue('mode');
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var code = 'seniverse_api.' + dropdown_mode + '(' + key + ', ' + addr + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const WEATHER_DAILY = function (_, generator) {
+    generator.definitions_['import_seniverse_api'] = "import seniverse_api";
+    var dropdown_mode = this.getFieldValue('mode');
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var day = generator.valueToCode(this, 'day', generator.ORDER_ATOMIC);
+    var code = 'seniverse_api.' + dropdown_mode + '(' + key + ', ' + addr + ', ' + day + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const WEATHER_HOUR = function (_, generator) {
+    generator.definitions_['import_seniverse_api'] = "import seniverse_api";
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var hour = generator.valueToCode(this, 'hour', generator.ORDER_ATOMIC);
+    var code = 'seniverse_api.weather_hourly(' + key + ', ' + addr + ', ' + hour + ')';
+    return [code, generator.ORDER_ATOMIC];
+}
+
+export const Weather_now = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var dropdown_mode = this.getFieldValue('mode');
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var code = dropdown_mode + '.request(' + key + ', ' + addr + ')\n';
+    return code;
+};
+
+export const Weather_now_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    if (content == 'none') {
+        var code = 'Weather_now.analysis()';
+    } else {
+        var code = 'Weather_now.analysis("' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Air_now_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    if (content == 'none') {
+        var code = 'Air_now.analysis()';
+    } else {
+        var code = 'Air_now.analysis("' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Weather_alarm_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    if (content == 'none') {
+        var code = 'Weather_alarm.analysis()';
+    } else {
+        var code = 'Weather_alarm.analysis("' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Life_suggestion_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    if (content == 'none') {
+        var code = 'Life_suggestion.analysis()';
+    } else {
+        var code = 'Life_suggestion.analysis("' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Tide_daily_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    if (content == 'none') {
+        var code = 'Tide_daily.analysis()';
+    } else {
+        var code = 'Tide_daily.analysis("' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Location_search_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    if (content == 'none') {
+        var code = 'Location_search.analysis()';
+    } else {
+        var code = 'Location_search.analysis("' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Weather_daily = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var dropdown_mode = this.getFieldValue('mode');
+    var key = generator.valueToCode(this, 'key', generator.ORDER_ATOMIC);
+    var addr = generator.valueToCode(this, 'addr', generator.ORDER_ATOMIC);
+    var day = generator.valueToCode(this, 'day', generator.ORDER_ATOMIC);
+    var code = dropdown_mode + '.request(' + key + ', ' + addr + ', ' + day + ')\n';
+    return code;
+};
+
+export const Weather_daily_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    var day = generator.valueToCode(this, 'day', generator.ORDER_ATOMIC);
+    if (content == 'none') {
+        var code = 'Weather_daily.analysis(' + day + ')';
+    } else {
+        var code = 'Weather_daily.analysis(' + day + ', "' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Air_daily_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    var day = generator.valueToCode(this, 'day', generator.ORDER_ATOMIC);
+    if (content == 'none') {
+        var code = 'Air_daily.analysis(' + day + ')';
+    } else {
+        var code = 'Air_daily.analysis(' + day + ', "' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Geo_sun_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    var day = generator.valueToCode(this, 'day', generator.ORDER_ATOMIC);
+    if (content == 'none') {
+        var code = 'Geo_sun.analysis(' + day + ')';
+    } else {
+        var code = 'Geo_sun.analysis(' + day + ', "' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};
+
+export const Geo_moon_content = function (_, generator) {
+    generator.definitions_['import_seniverse_api*'] = "from seniverse_api import *";
+    var content = this.getFieldValue('content');
+    var day = generator.valueToCode(this, 'day', generator.ORDER_ATOMIC);
+    if (content == 'none') {
+        var code = 'Geo_moon.analysis(' + day + ')';
+    } else {
+        var code = 'Geo_moon.analysis(' + day + ', "' + content + '")';
+    }
+    return [code, generator.ORDER_ATOMIC];
+};