mini_cocopi/blockly/blocks/python/extension_module.js

// Serial



Blockly.Blocks['serial_write_data_create_with_container'] = {
    init: function () {
        this.setColour("#22b845");
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_item);
        this.appendStatementInput('STACK');
        this.setTooltip('');
        this.contextMenu = false;
    }
};

Blockly.Blocks['serial_write_data_create_with_item'] = {
    init: function () {
        this.setColour("#22b845");
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_data);
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setTooltip('');
        this.contextMenu = false;
    }
};

Blockly.Blocks['serial_write_data'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/uart_serial_send_header.png", 110, 35, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_title_text);
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_data_bps_title)
            .appendField(new Blockly.FieldNumber(115200, 0, 500000, 1), "uart_bps")
            .appendField(Blockly.Msg.serialcomm_write_data_bps_attrib);
        this.appendValueInput("ADD1")
            .setCheck(null)
        // .appendField("Field 0");
        this.itemCount_ = 1;
        this.setColour("#22b845");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'iot': Blockly.Msg.Serial_Write_Data_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_iot),
                'ai': Blockly.Msg.Serial_Write_Data_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_ai)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    },
};
Blockly.Python['serial_write_data'] = function (block) {
    // var api = block.getFieldValue('t_api');
    var number_uart_bps = block.getFieldValue('uart_bps');
    var ai_uart_data = Blockly.Python.valueToCode(this, "ADD1", Blockly.Python.ORDER_NONE);
    Blockly.Python.definitions_['v831_import_serial'] = `import serial
SERIAL = serial.Serial("/dev/ttyS1",${number_uart_bps})
    `

    var code = `uart_data = bytes(str(${ai_uart_data})+"\\n","utf-8")
SERIAL.write(uart_data)
`
    return code;
};

Blockly.Blocks['serial_write_data_coco'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/cocorobo.png", 65, 65, { alt: "*", flipRtl: "FALSE" }));
        // this.appendDummyInput()
        //     .appendField(Blockly.Msg.serialcomm_write_title_text_coco);
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_data_bps_title)
            .appendField(new Blockly.FieldNumber(115200, 0, 500000, 1), "uart_bps");
        this.appendDummyInput()
            .appendField(Blockly.Msg.serial_send_data_on_send_data_cocorobo);
        /*this.appendValueInput("first_input")
            .setCheck(null)
            .appendField("Field 0");*/
        this.itemCount_ = 1;
        this.updateShape_();
        this.setMutator(new Blockly.Mutator(['serial_write_data_create_with_item']));
        this.setColour("#22b845");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'iot': Blockly.Msg.Serial_Write_Data_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_iot),
                'ai': Blockly.Msg.Serial_Write_Data_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_ai)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    },
    mutationToDom: function () {
        var container = document.createElement('mutation');
        container.setAttribute('items', this.itemCount_);
        return container;
    },
    domToMutation: function (xmlElement) {
        this.itemCount_ = parseInt(xmlElement.getAttribute('items'), 10);
        this.updateShape_();
    },
    decompose: function (workspace) {
        var containerBlock = workspace.newBlock('serial_write_data_create_with_container');
        containerBlock.initSvg();
        var connection = containerBlock.getInput('STACK').connection;
        for (var i = 0; i < this.itemCount_; i++) {
            var itemBlock = workspace.newBlock('serial_write_data_create_with_item');
            itemBlock.initSvg();
            connection.connect(itemBlock.previousConnection);
            connection = itemBlock.nextConnection;
        }
        return containerBlock;
    },
    compose: function (containerBlock) {
        var itemBlock = containerBlock.getInputTargetBlock('STACK');
        // Count number of inputs.
        var connections = [];
        while (itemBlock) {
            connections.push(itemBlock.valueConnection_);
            itemBlock = itemBlock.nextConnection &&
                itemBlock.nextConnection.targetBlock();
        }
        // Disconnect any children that don't belong.
        for (var i = 0; i < this.itemCount_; i++) {
            var connection = this.getInput('ADD' + i).connection.targetConnection;
            if (connection && connections.indexOf(connection) == -1) {
                connection.disconnect();
            }
        }
        this.itemCount_ = connections.length;
        this.updateShape_();
        // Reconnect any child blocks.
        for (var i = 0; i < this.itemCount_; i++) {
            Blockly.Mutator.reconnect(connections[i], this, 'ADD' + i);
        }
    },
    saveConnections: function (containerBlock) {
        var itemBlock = containerBlock.getInputTargetBlock('STACK');
        var i = 0;
        while (itemBlock) {
            var input = this.getInput('ADD' + i);
            itemBlock.valueConnection_ = input && input.connection.targetConnection;
            i++;
            itemBlock = itemBlock.nextConnection &&
                itemBlock.nextConnection.targetBlock();
        }
    },
    updateShape_: function () {
        for (var i = 0; i < this.itemCount_; i++) {
            if (!this.getInput('ADD' + i)) {
                var input = this.appendValueInput('ADD' + i);
                input.appendField(Blockly.Msg.serialcomm_write_item_first + i + Blockly.Msg.serialcomm_write_item_last);
                //input.appendField("資料 " + (i + 1) + ":");
                //input.appendField(new Blockly.FieldLabelSerializable("field" + (i + 1)), 'FIELD' + i);
                // input.appendField(new Blockly.FieldTextInput("資料" + (i + 1)), 'FIELD' + i)
            }
        }
        while (this.getInput('ADD' + i)) {
            this.removeInput('ADD' + i);
            i++;
        }
    },
};

Blockly.Python['serial_write_data_coco'] = function (block) {
    // var api = block.getFieldValue('t_api');
    var number_uart_bps = block.getFieldValue('uart_bps');
    var item_value = '';
    var ai_uart_data = "";
    for (var n = 0; n < this.itemCount_; n++) {
        item_value = Blockly.Python.valueToCode(this, 'ADD' + n, Blockly.Python.ORDER_NONE) || '';
        ai_uart_data += 'str(' + item_value + ') + \"|\" + ';
    }
    var ai_uart_data_final = ai_uart_data + "";
    Blockly.Python.definitions_['v831_import_serial'] = `import serial
SERIAL = serial.Serial("/dev/ttyS1",${number_uart_bps})
    `

    var code = `uart_data = bytes("SOF|"+${ai_uart_data_final.slice(0, -8)}+"|\\r\\n","utf-8")
SERIAL.write(uart_data)
`
    return code;
};

Blockly.Blocks['serial_read_data_setup'] = {
    init: function () {
        let types = getLocalStorage("type")
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/uart_serial_read_header.png", 110, 35, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_read_setup_title_text + Blockly.Msg.serialcomm_read_setup_title_text_1);
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_data_bps_title)
            .appendField(new Blockly.FieldNumber(115200, 0, 500000, 1), "uart_bps")
            .appendField(Blockly.Msg.serialcomm_write_data_bps_attrib);
        this.setColour("#22b845");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'iot': Blockly.Msg.Serial_Read_Data_Setup_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_iot),
                'ai': Blockly.Msg.Serial_Read_Data_Setup_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_ai)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};

Blockly.Python['serial_read_data_setup'] = function (block) {
    var number_uart_bps = block.getFieldValue('uart_bps');
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['v831_import_serial'] = `import serial
SERIAL = serial.Serial("/dev/ttyS1",${number_uart_bps})
`;
    Blockly.Python.definitions_['_read_serial_data'] = `def _read_serial_data(read_data,split, index):
    if read_data != None:
        read_str = ""
        try:
            read_str = str(read_data.decode("utf-8")).split(split)[index]
        except:
            read_str = str(read_data).split(split)[index]
        return read_str
`
    var code = "";

    return code;

};

Blockly.Blocks['serial_read_data_setup_arduino'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/uart_serial_read_header.png", 110, 35, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_read_setup_title_text_arduino);
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_data_bps_title)
            .appendField(new Blockly.FieldNumber(9600, 0, 500000, 1), "uart_bps")
            .appendField(Blockly.Msg.serialcomm_write_data_bps_attrib);
        this.setColour("#22b845");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'iot': Blockly.Msg.Serial_Read_Data_Setup_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_iot),
                'ai': Blockly.Msg.Serial_Read_Data_Setup_TOOLTIP.replace('%1', Blockly.Msg.serialcomm_write_on_ai)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};

Blockly.Python['serial_read_data_setup_arduino'] = function (block) {
    var number_uart_bps = block.getFieldValue('uart_bps');
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_["v831_import_os"] = `import os`
    Blockly.Python.definitions_['v831_import_serial_ardino_read'] = `import serial
SERIALPATH = "/dev/ttyUSB0" if os.path.exists("/dev/ttyUSB0") else "/dev/ttyACM0"
SERIAL = serial.Serial(SERIALPATH,${number_uart_bps})
`;
    var code = "";

    return code;

};
Blockly.Blocks['serial_read_data_all'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.Serial_Read_Data_all)
        // .appendField(new Blockly.FieldDropdown([
        //     ["serial_data", "serial_data"]
        // ]), "TYPE");
        this.setOutput(true, null);
        this.setColour("#22b845");
        this.setTooltip(Blockly.Msg.Serial_Read_Data_all);
        this.setHelpUrl("");
    }
}

Blockly.Python['serial_read_data_all'] = function (block) {
    var code = `SERIAL.readline().decode("UTF-8","ignore").strip()`;
    return [code, Blockly.Python.ORDER_NONE];
};
Blockly.Blocks['serial_read_data_all_usb'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.Serial_Read_Data_all_usb)
        // .appendField(new Blockly.FieldDropdown([
        //     ["serial_data", "serial_data"]
        // ]), "TYPE");
        this.setOutput(true, null);
        this.setColour("#22b845");
        this.setTooltip(Blockly.Msg.Serial_Read_Data_all);
        this.setHelpUrl("");
    }
}

Blockly.Python['serial_read_data_all_usb'] = function (block) {
    var code = `SERIAL.readline().decode("UTF-8","ignore").strip()`;
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['serial_read_data'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.ARD_SERIAL_RECEIVE_DATASET_GET_TEXT)
            .appendField(new Blockly.FieldDropdown([
                ["0", "0"],
                ["1", "1"],
                ["2", "2"],
                ["3", "3"],
                ["4", "4"],
                ["5", "5"],
                ["6", "6"],
                ["7", "7"],
                ["8", "8"],
                ["9", "9"],
                ["10", "10"],
                ["11", "11"],
            ]), "INDEX")
            .appendField(Blockly.Msg.ARD_SERIAL_RECEIVE_DATASET_TYPE_TEXT)
        // .appendField(new Blockly.FieldDropdown([
        //     [Blockly.Msg.ARD_SERIAL_RECEIVE_DATASET_TYPE_STRING, "0"],
        //     [Blockly.Msg.ARD_SERIAL_RECEIVE_DATASET_TYPE_INTEGER, "1"],
        //     [Blockly.Msg.ARD_SERIAL_RECEIVE_DATASET_TYPE_FLOAT, "2"],
        // ]), "TYPE");
        this.setOutput(true, null);
        this.setColour("#22b845");
        this.setTooltip(Blockly.Msg.Serial_Read_Data_TOOLTIP);
        this.setHelpUrl("");
    }
}

Blockly.Python['serial_read_data'] = function (block) {
    var index = parseInt(block.getFieldValue("INDEX")) + 1;
    // var type = block.getFieldValue("TYPE")
    // var type_1 = block.getFieldValue("TYPE_1")
    Blockly.Python.definitions_['_read_serial_data'] = `def _read_serial_data(read_data,split, index):
    if read_data != None:
        read_str = ""
        try:
            read_str = str(read_data.decode("utf-8")).split(split)[index]
        except:
            read_str = str(read_data).split(split)[index]
        return read_str
`
    var code = `_read_serial_data(SERIAL.readline().decode("UTF-8","ignore").strip(),"|",${index})`;

    return [code, Blockly.Python.ORDER_NONE];
}

Blockly.Blocks['serial_send_data_to_microbit'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/microbit_data_send_header.png", 90, 70, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_data_bps_title)
            .appendField("115200")
            .appendField(Blockly.Msg.serialcomm_write_data_bps_attrib);
        this.appendValueInput("NAME")
            // .appendField(Blockly.Msg.serial_send_data_on)
            .appendField(Blockly.Msg.serial_send_data_on_send_data);
        this.setInputsInline(false);
        this.setColour("#22b845");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.serial_send_data_on_send_data);
    }
};

Blockly.Python['serial_send_data_to_microbit'] = function (block) {
    var value_name = Blockly.Python.valueToCode(block, 'NAME', Blockly.Python.ORDER_ATOMIC) || "";
    // TODO: Assemble Python into code variable.

    Blockly.Python.definitions_["831_import_serial"] = `import serial
SERIAL = serial.Serial("/dev/ttyS1",115200)`
    var code = `uart_data = bytes(${value_name}+"\\n","utf-8")
SERIAL.write(uart_data)
`;
    return code

};

Blockly.Blocks['serial_send_data_to_arduino'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/arduino.png", 90, 70, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_title_text_arduino);
        this.appendDummyInput()
            .appendField(Blockly.Msg.serialcomm_write_data_bps_title)
            .appendField(new Blockly.FieldNumber(9600, 0, 500000, 1), "uart_bps")
            .appendField(Blockly.Msg.serialcomm_write_data_bps_attrib);
        this.appendValueInput("NAME")
            // .appendField(Blockly.Msg.serial_send_data_on)
            .appendField(Blockly.Msg.serial_send_data_on_send_data_control_panel_arduino);
        this.setInputsInline(false);
        this.setColour("#22b845");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.serial_send_data_on_send_data);
    }
};

Blockly.Python['serial_send_data_to_arduino'] = function (block) {
    var number_uart_bps = block.getFieldValue('uart_bps');
    var value_name = Blockly.Python.valueToCode(block, 'NAME', Blockly.Python.ORDER_ATOMIC) || "";
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_["v831_import_os"] = `import os`
    Blockly.Python.definitions_["v831_import_serial_ardino_read"] = `import serial
SERIALPATH = "/dev/ttyUSB0" if os.path.exists("/dev/ttyUSB0") else "/dev/ttyACM0"
SERIAL = serial.Serial(SERIALPATH,${number_uart_bps})`
    var code = `uart_data = bytes(${value_name}+"\\n","utf-8")
SERIAL.write(uart_data)
`;
    return code

};




/*
  ____                       
 / ___|  ___ _ ____   _____  
 \___ \ / _ \ '__\ \ / / _ \ 
  ___) |  __/ |   \ V / (_) |
 |____/ \___|_|    \_/ \___/ 

*/

var SERVO_BLOCK_COLOR = "#5bb2d6";

var ai_servo_timer = [
    "Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM",
    "Timer.TIMER0, Timer.CHANNEL1, mode=Timer.MODE_PWM",
    "Timer.TIMER0, Timer.CHANNEL2, mode=Timer.MODE_PWM",
    "Timer.TIMER0, Timer.CHANNEL3, mode=Timer.MODE_PWM",
    "Timer.TIMER1, Timer.CHANNEL0, mode=Timer.MODE_PWM",
    "Timer.TIMER1, Timer.CHANNEL1, mode=Timer.MODE_PWM",
    "Timer.TIMER1, Timer.CHANNEL2, mode=Timer.MODE_PWM",
    "Timer.TIMER1, Timer.CHANNEL3, mode=Timer.MODE_PWM",
    "Timer.TIMER2, Timer.CHANNEL0, mode=Timer.MODE_PWM",
    "Timer.TIMER2, Timer.CHANNEL1, mode=Timer.MODE_PWM",
    "Timer.TIMER2, Timer.CHANNEL2, mode=Timer.MODE_PWM",
    "Timer.TIMER2, Timer.CHANNEL3, mode=Timer.MODE_PWM",
    "Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM"
    // "Timer.TIMER0, Timer.CHANNEL1, mode=Timer.MODE_PWM"
];

var ai_servo_pin = [
    // '0', 
    '1', '2', '3', '13', '14', '15', '17', '21', '22', '23', '24', '29', '30']


Blockly.Blocks['extension_servo_setup_on_ai'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/esp32_servo_setup.png", 50, 40, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.servo_setup_ai);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(servoCloor);
        this.setTooltip(Blockly.Msg.extension_servo_setup_on_ai_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['extension_servo_setup_on_ai'] = function (block) {
    Blockly.Python.definitions_['v831_import_smbus2'] = `import smbus2`
    Blockly.Python.definitions_['v831_import_time'] = `import time`
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    Blockly.Python.definitions_['v831_import_CocoPi_multiFuncGpio'] = `from CocoPi import multiFuncGpio`;
    //     Blockly.Python.definitions_["v831_set_servo_S1_S2"] = `S1= multiFuncGpio(0,1)
    // S2= multiFuncGpio(1,1)`
    var code = '';
    return code;
};


Blockly.Blocks['extension_servo_write_on_ai'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.servo_set_gpio_ai)
            .appendField(new Blockly.FieldDropdown([
                ["S1", "S1"],
                ["S2", "S2"],
                ["P0", "P0"],
                ["P1", "P1"],
                ["P2", "P2"],
                ["P3", "P3"]
            ]), "gpio");
        this.appendValueInput("degree")
            .setCheck(null)
            .appendField(Blockly.Msg.servo_rotate_to_ai);
        this.appendDummyInput()
            .appendField(Blockly.Msg.servo_degree_ai);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(servoCloor);
        this.setTooltip(Blockly.Msg.extension_servo_write_on_ai_TOOLTIP);
        this.setHelpUrl("");
    }
};


let extension_servo_write_on_ai_list = []
Blockly.Python['extension_servo_write_on_ai'] = function (block) {
    var value_degree = Blockly.Python.valueToCode(block, 'degree', Blockly.Python.ORDER_ATOMIC);
    var value_gpio = block.getFieldValue('gpio');
    Blockly.Python.definitions_['v831_import_smbus2'] = `import smbus2`
    Blockly.Python.definitions_['v831_import_time'] = `import time`
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    let code = ""
    if (value_gpio == "S1" || value_gpio == "S2") {
        Blockly.Python.definitions_['v831_import_CocoPi_multiFuncGpio'] = `from CocoPi import multiFuncGpio`;
        const allBlocks = getBlocksByTypeName("extension_servo_write_on_ai")
        let onedegree = allBlocks[0].innerText
        let degree = 0
        let degree1 = 0
        try {
            if (value_gpio == "S1") {
                degree = onedegree.indexOf("S1") == 0 ? allBlocks[0].children[1].innerText : allBlocks[Math.floor((onedegree.indexOf("S1")) / 4)].children[1].innerText
            } else {
                degree1 = onedegree.indexOf("S2") == 0 ? allBlocks[0].children[1].innerText : allBlocks[Math.floor((onedegree.indexOf("S2")) / 4)].children[1].innerText
            }
        } catch (e) {
            console.log("error", e)
        }
        Blockly.Python.definitions_["v831_servo_init" + value_gpio] = `${value_gpio}= multiFuncGpio(${value_gpio[1] - 1},1)
${value_gpio}.servoCtrl(${allBlocks.length > 1 ? value_gpio == "S1" ? degree : degree1 : value_degree})`
        code = `${value_gpio}.servoCtrl(${value_degree})\n`
    } else {
        Blockly.Python.definitions_['v831_import_CocoPi_extServo'] = `from CocoPi import extServo`;
        Blockly.Python.definitions_["v831_servo_init_" + value_gpio] = `${value_gpio} = extServo(${value_gpio[1]})`
        code = `${value_gpio}.position(${value_degree})\n`
    }

    return code;
};

let servoCloor = "#386dc8"

var iot_servo_pin = [
    '4', '12', '13', '14', '15', '16', '17', '21', '22', '25', '27']

Blockly.Blocks['esp32_main_controller_servo_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/esp32_servo_setup.png", 50, 40, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.servo_setup);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(servoCloor);
        this.setTooltip(Blockly.Msg.Esp32_Main_Controller_Servo_Setup_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['esp32_main_controller_servo_setup'] = function (block) {
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['definition_servo_setup'] = '' +
        'from machine import Pin, PWM\n' +
        'import time\n' +
        '';

    var code = '\n';
    return code;
};


Blockly.Blocks['esp32_main_controller_servo_set'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.servo_set_gpio)
            .appendField(new Blockly.FieldDropdown([
                ["4", "0"],
                ["12", "1"],
                ["13", "2"],
                ["14", "3"],
                ["15", "4"],
                ["16", "5"],
                ["17", "6"],
                ["21", "7"],
                ["22", "8"],
                ["25", "9"],
                ["27", "10"]
            ]), "gpio");
        this.appendDummyInput()
            .appendField(Blockly.Msg.servo_rotate_to);
        this.appendValueInput("degree")
            .setCheck(null);
        this.appendDummyInput()
            .appendField(Blockly.Msg.servo_degree);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(servoCloor);
        this.setTooltip(Blockly.Msg.Esp32_Main_Controller_Servo_Set_TOOLTIP);
        this.setHelpUrl("");
    }
};


Blockly.Python['esp32_main_controller_servo_set'] = function (block) {
    var value_gpio = block.getFieldValue('gpio');
    var value_degree = Blockly.Python.valueToCode(block, 'degree', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    Blockly.Python.addVariable('S' + iot_servo_pin[value_gpio], 'S' + iot_servo_pin[value_gpio] + ' = PWM(Pin(' + iot_servo_pin[value_gpio] + '), freq=50, duty=0)', true);

    Blockly.Python.definitions_['definition_servo_set'] = '' +
        'def Servo(servo,angle):\n' +
        '    angle = angle - 90\n' +
        '    servo.freq(50)\n' +
        '    servo.duty(int(((angle+90)*2/180+0.5)/20*1023))\n' +
        '    time.sleep_ms(22)\n' +
        '';

    var code = '' +
        'Servo(S' + iot_servo_pin[value_gpio] + ',' + value_degree + ')\n' +
        '';
    return code;
};




/*
  __  __       _             
 |  \/  | ___ | |_ ___  _ __ 
 | |\/| |/ _ \| __/ _ \| '__|
 | |  | | (_) | || (_) | |   
 |_|  |_|\___/ \__\___/|_|   

*/

var MOTOR_BLOCK_COLOR = "#0000FF";



Blockly.Blocks['esp32_motor_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/motor_setup.png", 50, 40, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_motor_set_motor)
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(MOTOR_BLOCK_COLOR);
        this.setTooltip(Blockly.Msg.Esp32_Motor_Setup_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['esp32_motor_setup'] = function (block) {
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['esp32_controller_set_motor'] = '' +
        'import pca9685, machine, motor\n' +
        '\n' +
        '_iot_motor_i2c = machine.I2C(scl=machine.Pin(22), sda=machine.Pin(21))\n' +
        '_iot_motor = motor.DCMotors(_iot_motor_i2c)';

    var code = '';
    return code;
};


Blockly.Blocks['esp32_motor_run'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_motor_set_motor_turn)
            .appendField(new Blockly.FieldDropdown([
                ["A", "0"],
                ["B", "1"],
                ["C", "3"],
                ["D", "2"]
            ]), "motor_type")
            .appendField(Blockly.Msg.x_motor_set_motor_speed);
        this.appendValueInput("speed")
            .setCheck(null);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_motor_exec)
            // .appendField(new Blockly.FieldDropdown([
            //     [Blockly.Msg.x_motor_cw, "pos"],
            //     [Blockly.Msg.x_motor_acw, "neg"]
            // ]), "direction")
            .appendField(Blockly.Msg.x_motor_set_motor_turns);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(MOTOR_BLOCK_COLOR);
        this.setTooltip(Blockly.Msg.Esp32_Motor_Run_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['esp32_motor_run'] = function (block) {
    var dropdown_motor_type = block.getFieldValue('motor_type');
    var value_speed = Blockly.Python.valueToCode(block, 'speed', Blockly.Python.ORDER_ATOMIC);
    // var dropdown_direction = block.getFieldValue('direction');

    var code;
    if (value_speed.indexOf("-") == -1) {
        code = '_iot_motor.speed(' + dropdown_motor_type + ', (' + value_speed + '*16))\n';
    } else {
        code = '_iot_motor.speed(' + dropdown_motor_type + ', -(abs' + value_speed + '*16))\n';
    }

    return code;
};


Blockly.Blocks['ai_motor_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/motor_setup.png", 50, 40, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_motor_set_motor_ai)
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(servoCloor);
        this.setTooltip(Blockly.Msg.ai_motor_setup_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_motor_setup'] = function (block) {
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['v831_import_smbus2'] = `import smbus2`
    Blockly.Python.definitions_['v831_import_time'] = `import time`
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    Blockly.Python.definitions_['v831_import_CocoPi_stm8s_init'] = `from CocoPi import stm8s
iic_slaver=stm8s()
iic_slaver.clear()
del iic_slaver`;
    Blockly.Python.definitions_['v831_import_CocoPi_stm8s'] = `from CocoPi import dcMotor`;
    //     Blockly.Python.definitions_["v831_motor_init"] = `M1=dcMotor(1)
    // M2=dcMotor(2)`

    var code = '';
    return code;
};


Blockly.Blocks['ai_motor_run'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_motor_set_motor_turn_ai)
            .appendField(new Blockly.FieldDropdown([
                ["M1", "M1"],
                ["M2", "M2"],
                ["M3", "C"],
                ["M4", "D"],
                ["M5", "E"],
                ["M6", "F"]
            ]), "motor_type")
            .appendField(Blockly.Msg.x_motor_set_motor_speed_ai);
        this.appendValueInput("speed")
            .setCheck(null);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_motor_exec_ai)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.x_motor_cw_ai, "pos"],
                [Blockly.Msg.x_motor_acw_ai, "neg"]
            ]), "direction")
            .appendField(Blockly.Msg.x_motor_set_motor_turns_ai);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(servoCloor);
        this.setTooltip(Blockly.Msg.ai_motor_run_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_motor_run'] = function (block) {
    var dropdown_motor_type = block.getFieldValue('motor_type');
    var value_speed = Blockly.Python.valueToCode(block, 'speed', Blockly.Python.ORDER_ATOMIC);
    var dropdown_direction = block.getFieldValue('direction');
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['v831_import_smbus2'] = `import smbus2`
    Blockly.Python.definitions_['v831_import_time'] = `import time`
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    var code = ''
    if (dropdown_motor_type == "M1" || dropdown_motor_type == "M2") {
        Blockly.Python.definitions_['v831_import_CocoPi_stm8s_init'] = `from CocoPi import stm8s
iic_slaver=stm8s()
iic_slaver.clear()
del iic_slaver`;
        Blockly.Python.definitions_['v831_import_CocoPi_stm8s'] = `from CocoPi import dcMotor`;
        Blockly.Python.definitions_["v831dcMotorCtrlFun" + dropdown_motor_type] = `${dropdown_motor_type} = dcMotor(${dropdown_motor_type.slice(1, 2)})`
        if (dropdown_direction == 'pos') {
            code = `${dropdown_motor_type}.dcMotorCtrl(1,${value_speed})\n`
        }
        else {
            code = `${dropdown_motor_type}.dcMotorCtrl(0,${value_speed})\n`
        }
    } else {
        Blockly.Python.definitions_['v831_import_CocoPi_extDcMotor'] = `from CocoPi import extDcMotor`;
        Blockly.Python.definitions_["v831dcMotorCtrlFun" + dropdown_motor_type] = `${dropdown_motor_type} = extDcMotor("${dropdown_motor_type}")`
        if (dropdown_direction == 'pos') {
            code = `${dropdown_motor_type}.speedControl(${value_speed})\n`
        }
        else {
            code = `${dropdown_motor_type}.speedControl(-${value_speed})\n`
        }
    }
    return code;
};
// ai_motor_stop

Blockly.Blocks['ai_motor_stop'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_motor_set_motor_turn_ai)
            .appendField(new Blockly.FieldDropdown([
                ["M1", "M1"],
                ["M2", "M2"],
                ["M3", "C"],
                ["M4", "D"],
                ["M5", "E"],
                ["M6", "F"]
            ]), "motor_type")
            .appendField(Blockly.Msg.x_motor_set_motor_speed_stop);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(servoCloor);
        this.setTooltip(Blockly.Msg.x_motor_set_motor_speed_stop);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_motor_stop'] = function (block) {
    var dropdown_motor_type = block.getFieldValue('motor_type');
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['v831_import_smbus2'] = `import smbus2`
    Blockly.Python.definitions_['v831_import_time'] = `import time`
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    var code = ''
    if (dropdown_motor_type == "M1" || dropdown_motor_type == "M2") {
        Blockly.Python.definitions_['v831_import_CocoPi_stm8s_init'] = `from CocoPi import stm8s
iic_slaver=stm8s()
iic_slaver.clear()
del iic_slaver`;
        Blockly.Python.definitions_['v831_import_CocoPi_stm8s'] = `from CocoPi import dcMotor`;
        Blockly.Python.definitions_["v831dcMotorCtrlFun" + dropdown_motor_type] = `${dropdown_motor_type} = dcMotor(${dropdown_motor_type.slice(1, 2)})`
        
        code = `${dropdown_motor_type}.dcMotorCtrl(0,0)\n`
    } else {
        Blockly.Python.definitions_['v831_import_CocoPi_extDcMotor'] = `from CocoPi import extDcMotor`;
        Blockly.Python.definitions_["v831dcMotorCtrlFun" + dropdown_motor_type] = `${dropdown_motor_type} = extDcMotor("${dropdown_motor_type}")`
        code = `${dropdown_motor_type}.speedControl(0)\n`
    }
    return code;
};
/*
  _     _____ ____    __  __       _        _      
 | |   | ____|  _ \  |  \/  | __ _| |_ _ __(_)_  __
 | |   |  _| | | | | | |\/| |/ _` | __| '__| \ \/ /
 | |___| |___| |_| | | |  | | (_| | |_| |  | |>  < 
 |_____|_____|____/  |_|  |_|\__,_|\__|_|  |_/_/\_\

*/

let AILEDCOLOR = "#e8795b"

Blockly.Blocks['ai_led_matrix_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/led_setup.png", 50, 40, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_setup_ai);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_setup_ai_set_bright_1)
            .appendField(new Blockly.FieldNumber(50, 0, 255, 1), "brightness")
            .appendField(Blockly.Msg.x_led_matrix_setup_ai_set_bright_range);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_setup_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_setup'] = function (block) {
    var number_brightness = block.getFieldValue('brightness');

    Blockly.Python.definitions_['ai_controller_led_setup'] = '' +
        'from modules import ws2812\n' +
        '\n' +
        '_ai_led_matrix_total = 36\n' +
        '_ai_led_matrix = ws2812(24,_ai_led_matrix_total)\n' +
        '_ai_brightness = ' + number_brightness + '\n' +
        '\n' +
        'def rgba_to_rgb_conversion(red, green, blue):\n' +
        '    if _ai_brightness <= 255:\n' +
        '        alpha = _ai_brightness / 255\n' +
        '    elif _ai_brightness > 255:\n' +
        '        alpha = 255 / 255\n' +
        '    elif _ai_brightness < 0:\n' +
        '        alpha = 0 / 255\n' +
        '    final_red = int((1 - alpha) * 0 + alpha * red)\n' +
        '    final_green = int((1 - alpha) * 0 + alpha * green)\n' +
        '    final_blue = int((1 - alpha) * 0 + alpha * blue)\n' +
        '    final = (final_red, final_green, final_blue)\n' +
        '    return final\n' +
        '';
    // TODO: Assemble Python into code variable.
    var code = '';
    return code;
};

Blockly.Blocks['ai_led_matrix_set_bright'] = {
    init: function () {
        this.appendValueInput("brightness")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_ai_set_brightness_1);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_setup_ai_set_bright_range);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_set_bright_TOOLTIP);
        this.setHelpUrl("");
    }
};
Blockly.Python['ai_led_matrix_set_bright'] = function (block) {
    var value_brightness = Blockly.Python.valueToCode(block, 'brightness', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = '_ai_brightness = ' + value_brightness + '\n';
    return code;
};

Blockly.Blocks['ai_led_matrix_xy'] = {
    init: function () {
        this.appendValueInput("x")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_ai_x);
        this.appendValueInput("y")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_ai_y);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_xy_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_xy'] = function (block) {
    var value_x = Blockly.Python.valueToCode(block, 'x', Blockly.Python.ORDER_ATOMIC);
    var value_y = Blockly.Python.valueToCode(block, 'y', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.

    var code = value_x + ',' + value_y;
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['ai_led_matrix_wh'] = {
    init: function () {
        this.appendValueInput("w")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_ai);
        this.appendValueInput("h")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_height_ai);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_wh_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_wh'] = function (block) {
    var value_w = Blockly.Python.valueToCode(block, 'w', Blockly.Python.ORDER_ATOMIC);
    var value_h = Blockly.Python.valueToCode(block, 'h', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = value_w + ',' + value_h;
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['ai_led_matrix_color_picker'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_color_ai)
            .appendField(new Blockly.FieldColour("#ff0000"), "color");
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Color_Picker_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_color_picker'] = function (block) {
    var color = block.getFieldValue('color');


    var d = 0,
        e = 0,
        f = 0;
    try {
        7 == color.length && (d = parseInt(color.substring(1, 3), 16),
            e = parseInt(color.substring(3, 5), 16),
            f = parseInt(color.substring(5, 7), 16))
    } catch (g) { }

    // TODO: Assemble Python into code variable.
    var code = d + ',' + e + ',' + f;
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['ai_led_matrix_draw_pixel'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/led_draw-pixel.png", 30, 30, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_title_ai);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_pixel_ai);
        this.appendValueInput("color")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_color_ai);
        this.appendValueInput("coordinate")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_coord_ai);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_draw_pixel_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_draw_pixel'] = function (block) {
    var value_color = Blockly.Python.valueToCode(block, 'color', Blockly.Python.ORDER_ATOMIC);
    var value_coordinate = Blockly.Python.valueToCode(block, 'coordinate', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = 'ai_pixel_value_coordinate = ' + value_coordinate + '\n' +
        '_a = _ai_led_matrix.set_led((((ai_pixel_value_coordinate[1]*6)//6)-1)*6+(ai_pixel_value_coordinate[0]-1),rgba_to_rgb_conversion' + value_color + ')\n';
    return code;
};



Blockly.Blocks['ai_led_matrix_draw_rectangle'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/led_draw-rect.png", 30, 30, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_title_ai);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_rect_ai);
        this.appendValueInput("color")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_color_ai);
        this.appendValueInput("coordinate")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_coord_ai);
        this.appendValueInput("size")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_size_ai);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_draw_rectangle_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_draw_rectangle'] = function (block) {
    var value_color = Blockly.Python.valueToCode(block, 'color', Blockly.Python.ORDER_ATOMIC);
    var value_coordinate = Blockly.Python.valueToCode(block, 'coordinate', Blockly.Python.ORDER_ATOMIC);
    var value_size = Blockly.Python.valueToCode(block, 'size', Blockly.Python.ORDER_ATOMIC);

    Blockly.Python.codeFunctions_['ai_led_matrix_draw_rectangle_setup'] = '' +
        'def _ai_led_draw_rectangle(x, y, w, h, rgb):\n' +
        '    for i in range(x, x+ w, 1):\n' +
        '        for j in range(y, y+h, 1):\n' +
        '            _a = _ai_led_matrix.set_led((((j*6)//6)-1)*6+(i-1),(rgb))\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    // var comma_location = value_coordinate.indexOf(",");
    // var last_bracket_location = value_coordinate.length;
    // var cord_x = value_coordinate.substr(1, comma_location - 1);
    // var cord_y_pre = value_coordinate.substr(comma_location + 1, last_bracket_location - 1);
    // var cord_y = cord_y_pre.substring(0, cord_y_pre.length - 1)
    // // console.log(value_coordinate + ": " + cord_x + ", " + cord_y);
    // var comma_location_size = value_size.indexOf(",");
    // var last_bracket_location_size = value_size.length;
    // var size_width = value_size.substr(1, comma_location_size - 1);
    // var size_height_pre = value_size.substr(comma_location_size + 1, last_bracket_location_size - 1);
    // var size_height = size_height_pre.substring(0, size_height_pre.length - 1)
    // console.log("Size string length: " + last_bracket_location_size);
    // console.log("Size is " + value_size + ": " + size_width + ", " + size_height);

    var code = 'ai_rectangle_value_coordinate = ' + value_coordinate + '\n' +
        'ai_rectangle_value_size = ' + value_size + '\n' +
        '_ai_led_draw_rectangle(ai_rectangle_value_coordinate[0], ai_rectangle_value_coordinate[1], ai_rectangle_value_size[0], ai_rectangle_value_size[1], rgba_to_rgb_conversion' + value_color + ')\n';
    return code;
};


Blockly.Blocks['ai_led_pattern_6x6'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(
                new Blockly.FieldImage("./../blockly/media/pattern.png", 25, 25, "15"))
            .appendField(Blockly.Msg.LED_DRAW + Blockly.Msg.LED_PATTERN);
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "6_1")
            .appendField((new Blockly.FieldColour("#000000")), "6_2")
            .appendField((new Blockly.FieldColour("#000000")), "6_3")
            .appendField((new Blockly.FieldColour("#000000")), "6_4")
            .appendField((new Blockly.FieldColour("#000000")), "6_5")
            .appendField((new Blockly.FieldColour("#000000")), "6_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "5_1")
            .appendField((new Blockly.FieldColour("#000000")), "5_2")
            .appendField((new Blockly.FieldColour("#000000")), "5_3")
            .appendField((new Blockly.FieldColour("#000000")), "5_4")
            .appendField((new Blockly.FieldColour("#000000")), "5_5")
            .appendField((new Blockly.FieldColour("#000000")), "5_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "4_1")
            .appendField((new Blockly.FieldColour("#000000")), "4_2")
            .appendField((new Blockly.FieldColour("#000000")), "4_3")
            .appendField((new Blockly.FieldColour("#000000")), "4_4")
            .appendField((new Blockly.FieldColour("#000000")), "4_5")
            .appendField((new Blockly.FieldColour("#000000")), "4_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "3_1")
            .appendField((new Blockly.FieldColour("#000000")), "3_2")
            .appendField((new Blockly.FieldColour("#000000")), "3_3")
            .appendField((new Blockly.FieldColour("#000000")), "3_4")
            .appendField((new Blockly.FieldColour("#000000")), "3_5")
            .appendField((new Blockly.FieldColour("#000000")), "3_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "2_1")
            .appendField((new Blockly.FieldColour("#000000")), "2_2")
            .appendField((new Blockly.FieldColour("#000000")), "2_3")
            .appendField((new Blockly.FieldColour("#000000")), "2_4")
            .appendField((new Blockly.FieldColour("#000000")), "2_5")
            .appendField((new Blockly.FieldColour("#000000")), "2_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "1_1")
            .appendField((new Blockly.FieldColour("#000000")), "1_2")
            .appendField((new Blockly.FieldColour("#000000")), "1_3")
            .appendField((new Blockly.FieldColour("#000000")), "1_4")
            .appendField((new Blockly.FieldColour("#000000")), "1_5")
            .appendField((new Blockly.FieldColour("#000000")), "1_6")
            .appendField("  ");
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setColour(AILEDCOLOR);
        this.setTooltip('');
        this.setHelpUrl('');
    }
};

var ai_led_pattern_6x6_length = 0;

Blockly.Python['ai_led_pattern_6x6'] = function (block) {
    // TODO: Assemble Python into code variable.
    var rgb = [];
    ai_led_pattern_6x6_length = ai_led_pattern_6x6_length + 1;
    for (var i = 6; i >= 1; i--) {
        for (var j = 1; j < 7; j++) {
            var color = block.getFieldValue(i + '_' + j);
            var d = 0,
                e = 0,
                f = 0;
            try {
                7 == color.length && (d = parseInt(color.substring(1, 3), 16),
                    e = parseInt(color.substring(3, 5), 16),
                    f = parseInt(color.substring(5, 7), 16))
            } catch (g) { }
            rgb[(parseInt((i * 6) / 6) - 1) * 6 + (j - 1)] = '(rgba_to_rgb_conversion(' + d + ',' + e + ',' + f + '))';
        }
    }
    Blockly.Python.codeFunctions_['ai_led_pattern_6x6_setup'] = '' +
        'def _ai_led_draw_picture(rgb):\n' +
        '    for i in range(6, 0, -1):\n' +
        '        for j in range(1, 7):\n' +
        '            _a = _ai_led_matrix.set_led((((i*6)//6)-1)*6+(j-1),(rgb[(((i*6)//6)-1)*6+(j-1)]))\n' +
        '\n';

    Blockly.Python.codeFunctions_['ai_led_pattern_6x6_' + ai_led_pattern_6x6_length + '_setup'] = '' +
        'ai_led_pattern_6x6_' + ai_led_pattern_6x6_length + ' = [' + rgb + ']' +
        '\n';
    var code = '_ai_led_draw_picture(ai_led_pattern_6x6_' + ai_led_pattern_6x6_length + ')\n';
    return code;
};

Blockly.Blocks['ai_led_matrix_show_above'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_show_above_ai);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_show_above_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_show_above'] = function (block) {
    // TODO: Assemble Python into code variable.
    var code = '_ai_led_matrix.display()\n';
    return code;
};


Blockly.Blocks['ai_led_matrix_clear_screen'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_clear_all_ai);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_clear_screen_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_clear_screen'] = function (block) {
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['ai_led_matrix_clear_screen_setup'] = '' +
        'def _ai_led_draw_rectangle(x, y, w, h, rgb):\n' +
        '    for i in range(x, x+ w, 1):\n' +
        '        for j in range(y, y+h, 1):\n' +
        '            _a = _ai_led_matrix.set_led((((i*6)//6)-1)*6+(j-1),(rgb))\n' +
        '';

    var code = '' +
        '_ai_led_draw_rectangle(1, 1, 6, 6, rgba_to_rgb_conversion(0, 0, 0))\n' +
        '_ai_led_matrix.display()\n' +
        '';
    return code;
};

Blockly.Blocks['ai_led_matrix_rgb_value_input'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_r);
        this.appendValueInput("rgb_value_r")
            .setCheck(null)
            .appendField("");
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_g);
        this.appendValueInput("rgb_value_g")
            .setCheck(null)
            .appendField("");
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_b);
        this.appendValueInput("rgb_value_b")
            .setCheck(null)
            .appendField("");
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_rgb_value_input_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['ai_led_matrix_rgb_value_input'] = function (block) {
    var value_rgb_value_r = Blockly.Python.valueToCode(block, 'rgb_value_r', Blockly.Python.ORDER_ATOMIC);
    var value_rgb_value_g = Blockly.Python.valueToCode(block, 'rgb_value_g', Blockly.Python.ORDER_ATOMIC);
    var value_rgb_value_b = Blockly.Python.valueToCode(block, 'rgb_value_b', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = '' + value_rgb_value_r + ',' + value_rgb_value_g + ',' + value_rgb_value_b + '';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['iot_led_matrix_rgb_value_input'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_r);
        this.appendValueInput("rgb_value_r")
            .setCheck(null)
            .appendField("");
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_g);
        this.appendValueInput("rgb_value_g")
            .setCheck(null)
            .appendField("");
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_b);
        this.appendValueInput("rgb_value_b")
            .setCheck(null)
            .appendField("");
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Rgb_Value_Input_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_rgb_value_input'] = function (block) {
    var value_rgb_value_r = Blockly.Python.valueToCode(block, 'rgb_value_r', Blockly.Python.ORDER_ATOMIC);
    var value_rgb_value_g = Blockly.Python.valueToCode(block, 'rgb_value_g', Blockly.Python.ORDER_ATOMIC);
    var value_rgb_value_b = Blockly.Python.valueToCode(block, 'rgb_value_b', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = '' + value_rgb_value_r + ',' + value_rgb_value_g + ',' + value_rgb_value_b + '';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};


Blockly.Blocks['iot_led_matrix_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/led_setup.png", 50, 40, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_setup_iot);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_setup_iot_io)
            .appendField(new Blockly.FieldDropdown([
                ["25", "25"],
                ["15", "15"]
            ]), "io");
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_setup_iot_set_bright_1)
            .appendField(new Blockly.FieldNumber(50, 0, 255, 1), "brightness")
            .appendField(Blockly.Msg.x_led_matrix_setup_iot_set_bright_range);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Setup_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_setup'] = function (block) {

    var number_brightness = block.getFieldValue('brightness');
    var dropdown_io = block.getFieldValue('io');


    Blockly.Python.definitions_['iot_controller_led_setup'] = '' +
        'import machine, neopixel, time\n' +
        '_6x6_led_matrix = neopixel.NeoPixel(machine.Pin(' + dropdown_io + '), 36)\n' +
        '_iot_brightness = ' + number_brightness + '\n' +
        '\n' +
        'def rgba_to_rgb_conversion(red, green, blue):\n' +
        '    if _iot_brightness <= 255:\n' +
        '        alpha = _iot_brightness / 255\n' +
        '    elif _iot_brightness > 255:\n' +
        '        alpha = 255 / 255\n' +
        '    elif _iot_brightness < 0:\n' +
        '        alpha = 0 / 255\n' +
        '    final_red = int((1 - alpha) * 0 + alpha * red)\n' +
        '    final_green = int((1 - alpha) * 0 + alpha * green)\n' +
        '    final_blue = int((1 - alpha) * 0 + alpha * blue)\n' +
        '    final = (final_red, final_green, final_blue)\n' +
        '    return final\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '';
    return code;
};


Blockly.Blocks['iot_led_matrix_set_bright'] = {
    init: function () {
        this.appendValueInput("brightness")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_ai_set_brightness_1);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_setup_ai_set_bright_range);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Set_Bright_TOOLTIP);
        this.setHelpUrl("");
    }
};
Blockly.Python['iot_led_matrix_set_bright'] = function (block) {
    var value_brightness = Blockly.Python.valueToCode(block, 'brightness', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = '_iot_brightness = ' + value_brightness + '\n';
    return code;
};

Blockly.Blocks['iot_led_matrix_xy'] = {
    init: function () {
        this.appendValueInput("x")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_iot_x);
        this.appendValueInput("y")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_iot_y);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_xy_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_xy'] = function (block) {
    var value_x = Blockly.Python.valueToCode(block, 'x', Blockly.Python.ORDER_ATOMIC);
    var value_y = Blockly.Python.valueToCode(block, 'y', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.

    var code = value_x + ',' + value_y;
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['iot_led_matrix_wh'] = {
    init: function () {
        this.appendValueInput("w")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_width_iot);
        this.appendValueInput("h")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_height_iot);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_wh_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_wh'] = function (block) {
    var value_w = Blockly.Python.valueToCode(block, 'w', Blockly.Python.ORDER_ATOMIC);
    var value_h = Blockly.Python.valueToCode(block, 'h', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = value_w + ',' + value_h;
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['iot_led_matrix_color_picker'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_color_iot)
            .appendField(new Blockly.FieldColour("#ff0000"), "color");
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Color_Picker_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_color_picker'] = function (block) {
    var color = block.getFieldValue('color');


    var d = 0,
        e = 0,
        f = 0;
    try {
        7 == color.length && (d = parseInt(color.substring(1, 3), 16),
            e = parseInt(color.substring(3, 5), 16),
            f = parseInt(color.substring(5, 7), 16))
    } catch (g) { }

    // TODO: Assemble Python into code variable.
    var code = d + ',' + e + ',' + f;
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_MEMBER];
};

Blockly.Blocks['iot_led_matrix_draw_pixel'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/led_draw-pixel.png", 30, 30, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_title_iot);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_pixel_iot);
        this.appendValueInput("color")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_color_iot);
        this.appendValueInput("coordinate")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_coord_iot);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Draw_Pixel_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_draw_pixel'] = function (block) {
    var value_color = Blockly.Python.valueToCode(block, 'color', Blockly.Python.ORDER_ATOMIC);
    var value_coordinate = Blockly.Python.valueToCode(block, 'coordinate', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    // _6x6_led_matrix[(((1*6)//6)-1)*6+(1-1)] = (0, 0, 255)
    var code = 'iot_pixel_value_coordinate = ' + value_coordinate + '\n' +
        '_6x6_led_matrix[(((iot_pixel_value_coordinate[1]*6)//6)-1)*6+(iot_pixel_value_coordinate[0]-1)] = rgba_to_rgb_conversion' + value_color + '\n';
    return code;
};

Blockly.Blocks['iot_led_matrix_draw_rectangle'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/led_draw-rect.png", 30, 30, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_title_iot);
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_draw_rect_ai);
        this.appendValueInput("color")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_color_ai);
        this.appendValueInput("coordinate")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_coord_ai);
        this.appendValueInput("size")
            .setCheck(null)
            .appendField(Blockly.Msg.x_led_matrix_parameter_size_ai);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Draw_Rectangle_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_draw_rectangle'] = function (block) {
    var value_color = Blockly.Python.valueToCode(block, 'color', Blockly.Python.ORDER_ATOMIC);
    var value_coordinate = Blockly.Python.valueToCode(block, 'coordinate', Blockly.Python.ORDER_ATOMIC);
    var value_size = Blockly.Python.valueToCode(block, 'size', Blockly.Python.ORDER_ATOMIC);

    Blockly.Python.definitions_['iot_led_matrix_draw_rectangle_setup'] = '' +
        'def _iot_led_draw_rectangle(x, y, w, h, rgb):\n' +
        '    for i in range(x, x+ w, 1):\n' +
        '        for j in range(y, y+h, 1):\n' +
        '            _6x6_led_matrix[(((j*6)//6)-1)*6+(i-1)] = (rgb)' +
        '\n';
    // TODO: Assemble Python into code variable.


    // var comma_location = value_coordinate.indexOf(",");
    // var last_bracket_location = value_coordinate.length;
    // var cord_x = value_coordinate.substr(1, comma_location - 1);
    // var cord_y_pre = value_coordinate.substr(comma_location + 1, last_bracket_location - 1);
    // var cord_y = cord_y_pre.substring(0, cord_y_pre.length - 1)
    // // console.log(value_coordinate + ": " + cord_x + ", " + cord_y);
    // var comma_location_size = value_size.indexOf(",");
    // var last_bracket_location_size = value_size.length;
    // var size_width = value_size.substr(1, comma_location_size - 1);
    // var size_height_pre = value_size.substr(comma_location_size + 1, last_bracket_location_size - 1);
    // var size_height = size_height_pre.substring(0, size_height_pre.length - 1)
    // console.log("Size string length: " + last_bracket_location_size);
    // console.log("Size is " + value_size + ": " + size_width + ", " + size_height);

    var code = 'iot_rectangle_value_coordinate = ' + value_coordinate + '\n' +
        'iot_rectangle_value_size = ' + value_size + '\n' +
        '_iot_led_draw_rectangle(iot_rectangle_value_coordinate[0], iot_rectangle_value_coordinate[1], iot_rectangle_value_size[0], iot_rectangle_value_size[1], rgba_to_rgb_conversion' + value_color + ')\n';
    return code;
};

Blockly.Blocks['iot_led_pattern_6x6'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(
                new Blockly.FieldImage("./../blockly/media/pattern.png", 25, 25, "15"))
            .appendField(Blockly.Msg.LED_DRAW + Blockly.Msg.LED_PATTERN);
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "6_1")
            .appendField((new Blockly.FieldColour("#000000")), "6_2")
            .appendField((new Blockly.FieldColour("#000000")), "6_3")
            .appendField((new Blockly.FieldColour("#000000")), "6_4")
            .appendField((new Blockly.FieldColour("#000000")), "6_5")
            .appendField((new Blockly.FieldColour("#000000")), "6_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "5_1")
            .appendField((new Blockly.FieldColour("#000000")), "5_2")
            .appendField((new Blockly.FieldColour("#000000")), "5_3")
            .appendField((new Blockly.FieldColour("#000000")), "5_4")
            .appendField((new Blockly.FieldColour("#000000")), "5_5")
            .appendField((new Blockly.FieldColour("#000000")), "5_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "4_1")
            .appendField((new Blockly.FieldColour("#000000")), "4_2")
            .appendField((new Blockly.FieldColour("#000000")), "4_3")
            .appendField((new Blockly.FieldColour("#000000")), "4_4")
            .appendField((new Blockly.FieldColour("#000000")), "4_5")
            .appendField((new Blockly.FieldColour("#000000")), "4_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "3_1")
            .appendField((new Blockly.FieldColour("#000000")), "3_2")
            .appendField((new Blockly.FieldColour("#000000")), "3_3")
            .appendField((new Blockly.FieldColour("#000000")), "3_4")
            .appendField((new Blockly.FieldColour("#000000")), "3_5")
            .appendField((new Blockly.FieldColour("#000000")), "3_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "2_1")
            .appendField((new Blockly.FieldColour("#000000")), "2_2")
            .appendField((new Blockly.FieldColour("#000000")), "2_3")
            .appendField((new Blockly.FieldColour("#000000")), "2_4")
            .appendField((new Blockly.FieldColour("#000000")), "2_5")
            .appendField((new Blockly.FieldColour("#000000")), "2_6")
            .appendField("  ");
        this.appendDummyInput()
            .appendField("  ")
            .appendField((new Blockly.FieldColour("#000000")), "1_1")
            .appendField((new Blockly.FieldColour("#000000")), "1_2")
            .appendField((new Blockly.FieldColour("#000000")), "1_3")
            .appendField((new Blockly.FieldColour("#000000")), "1_4")
            .appendField((new Blockly.FieldColour("#000000")), "1_5")
            .appendField((new Blockly.FieldColour("#000000")), "1_6")
            .appendField("  ");
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setColour(AILEDCOLOR);
        this.setTooltip('');
        this.setHelpUrl('');
    }
};

var iot_led_pattern_6x6_length = 0;

Blockly.Python['iot_led_pattern_6x6'] = function (block) {
    // TODO: Assemble Python into code variable.
    var rgb = [];
    iot_led_pattern_6x6_length = iot_led_pattern_6x6_length + 1;
    for (var i = 6; i >= 1; i--) {
        for (var j = 1; j < 7; j++) {
            var color = block.getFieldValue(i + '_' + j);
            var d = 0,
                e = 0,
                f = 0;
            try {
                7 == color.length && (d = parseInt(color.substring(1, 3), 16),
                    e = parseInt(color.substring(3, 5), 16),
                    f = parseInt(color.substring(5, 7), 16))
            } catch (g) { }
            rgb[(parseInt((i * 6) / 6) - 1) * 6 + (j - 1)] = '(rgba_to_rgb_conversion(' + d + ',' + e + ',' + f + '))';
        }
    }
    Blockly.Python.codeFunctions_['iot_led_pattern_6x6_setup'] = '' +
        'def _iot_led_draw_picture(rgb):\n' +
        '    for i in range(6, 0, -1):\n' +
        '        for j in range(1, 7):\n' +
        '            _6x6_led_matrix[(((i*6)//6)-1)*6+(j-1)] = (rgb[(((i*6)//6)-1)*6+(j-1)])\n' +
        '\n';
    Blockly.Python.codeFunctions_['iot_led_pattern_6x6_' + iot_led_pattern_6x6_length + '_setup'] = '' +
        'iot_led_pattern_6x6_' + iot_led_pattern_6x6_length + ' = [' + rgb + ']' +
        '\n';
    var code = '_iot_led_draw_picture(iot_led_pattern_6x6_' + iot_led_pattern_6x6_length + ')\n';
    return code;
};

Blockly.Blocks['iot_led_matrix_show_above'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_show_above_iot);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Iot_Led_Matrix_Show_Above_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_show_above'] = function (block) {
    // TODO: Assemble Python into code variable.
    var code = '_6x6_led_matrix.write()\n';
    return code;
};

Blockly.Blocks['iot_led_matrix_clear_screen'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_led_matrix_clear_all_ai);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.ai_led_matrix_clear_screen_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_led_matrix_clear_screen'] = function (block) {
    // TODO: Assemble Python into code variable.
    Blockly.Python.definitions_['iot_led_matrix_clear_screen_setup'] = '' +
        'def _iot_led_draw_rectangle(x, y, w, h, rgb):\n' +
        '    for i in range(x, x+ w, 1):\n' +
        '        for j in range(y, y+h, 1):\n' +
        '            _6x6_led_matrix[(((j*6)//6)-1)*6+(i-1)] = (rgb)' +
        '\n';

    var code = '' +
        '_iot_led_draw_rectangle(1,1,6,6,rgba_to_rgb_conversion(0,0,0))\n' +
        '_6x6_led_matrix.write()\n' +
        '';
    return code;
};



/*
  _     _____ ____    ____  _        _       
 | |   | ____|  _ \  / ___|| |_ _ __(_)_ __  
 | |   |  _| | | | | \___ \| __| '__| | '_ \ 
 | |___| |___| |_| |  ___) | |_| |  | | |_) |
 |_____|_____|____/  |____/ \__|_|  |_| .__/ 
                                      |_|    
*/

var ESP32_LED_STRIP_COLOR = AILEDCOLOR;

Blockly.Blocks['esp32_main_controller_led_strip_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/led_strip_setup.png", 45, 45, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_setup_text)
            .appendField(new Blockly.FieldVariable("STRIP"), "varitem")
            .appendField(Blockly.Msg.ledstrip_setup);
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_set_gpio)
            .appendField(new Blockly.FieldDropdown([
                ["S1", "1"],
                ["S2", "2"]
            ]), "value_io");
        this.appendValueInput("count")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_total_led);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ESP32_LED_STRIP_COLOR);
        this.setHelpUrl("");
        this.setTooltip();
    }
};

Blockly.Python['esp32_main_controller_led_strip_setup'] = function (block) {
    var variable_name = Blockly.Python.variableDB_.getName(block.getFieldValue('varitem'), Blockly.Variables.NAME_TYPE);
    var value_io = block.getFieldValue('value_io');
    var value_count = Blockly.Python.valueToCode(block, 'count', Blockly.Python.ORDER_ATOMIC);

    Blockly.Python.definitions_['v831_import_time'] = `import time`;

    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    Blockly.Python.definitions_['v831_import_CocoPi_multiFuncGpio'] = `from CocoPi import multiFuncGpio`;
    Blockly.Python.addVariable(variable_name, `${variable_name} = multiFuncGpio(${value_io - 1},7)`, true);
    var code = ""
    return code;
};

Blockly.Blocks['esp32_main_controller_led_strip_set_bright'] = {
    init: function () {
        this.appendValueInput("brightness")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_brightness_1);
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_set_brightness_after);
        this.setInputsInline(true);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Esp32_Main_Controller_Led_strip_set_bright_TOOLTIP);
        this.setHelpUrl("");
    }
};
Blockly.Python['esp32_main_controller_led_strip_set_bright'] = function (block) {
    var value_brightness = Blockly.Python.valueToCode(block, 'brightness', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = '_ai_brightness = ' + value_brightness + '\n';
    return code;
};


Blockly.Blocks['esp32_main_controller_led_strip_set'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_set_gpio)
            .appendField(new Blockly.FieldDropdown([
                ["S1", "1"],
                ["S2", "2"]
            ]), "value_io");
        this.appendValueInput("location")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_no);
        this.appendValueInput("color")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_color);
        this.appendValueInput("brightness")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_brightness_setup);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ESP32_LED_STRIP_COLOR);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.Esp32_Main_Controller_Led_Strip_Set_TOOLTIP.replace('%1', "CocoPi"));
    }
};

Blockly.Python['esp32_main_controller_led_strip_set'] = function (block) {
    var value_location = Blockly.Python.valueToCode(block, 'location', Blockly.Python.ORDER_ATOMIC);
    var value_color = Blockly.Python.valueToCode(block, 'color', Blockly.Python.ORDER_ATOMIC);
    var value_brightness = Blockly.Python.valueToCode(block, 'brightness', Blockly.Python.ORDER_ATOMIC);
    var value_io = block.getFieldValue('value_io');
    // var value_count = Blockly.Python.valueToCode(block, 'count', Blockly.Python.ORDER_ATOMIC);
    Blockly.Python.definitions_['v831_import_time'] = `import time`;
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    Blockly.Python.definitions_['v831_import_CocoPi_multiFuncGpio'] = `from CocoPi import multiFuncGpio`;
    Blockly.Python.addVariable("STRIP" + value_io, `STRIP${value_io} = multiFuncGpio(${value_io - 1},7)
STRIP${value_io}.setBrightness(${value_brightness})`, true);

    Blockly.Python.addVariable("setLedColor", 'setLedColor = ""', true)
    // TODO: Assemble Python into code variable.
    console.log(value_color)
    var code = `setLedColor = ${value_color}
STRIP${value_io}.setRgbSerialColor(${value_location} - 1 ,setLedColor[0],setLedColor[1],setLedColor[2])
STRIP${value_io}.rgbSerialShow()
time.sleep(0.01)
`

    return code;
};

Blockly.Blocks['esp32_main_controller_led_strip_set_one'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_set_gpio)
            .appendField(new Blockly.FieldDropdown([
                ["S1", "1"],
                ["S2", "2"]
            ]), "value_io").appendField(Blockly.Msg.ledstrip_setup_text);
        this.appendValueInput("location")
            .setCheck(null)
            .appendField(Blockly.Msg.uav_get_shooting_value_0);
        this.appendValueInput("location1")
            .setCheck(null)
            .appendField(Blockly.Msg.OLCD_LINE_END)
        this.appendValueInput("color")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_color);
        this.appendValueInput("brightness")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_brightness_setup);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ESP32_LED_STRIP_COLOR);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.Esp32_Main_Controller_Led_Strip_Set_TOOLTIP.replace('%1', "CocoPi"));
    }
};

Blockly.Python['esp32_main_controller_led_strip_set_one'] = function (block) {
    var value_color = Blockly.Python.valueToCode(block, 'color', Blockly.Python.ORDER_ATOMIC);
    var value_brightness = Blockly.Python.valueToCode(block, 'brightness', Blockly.Python.ORDER_ATOMIC);
    var location1 = Blockly.Python.valueToCode(block, 'location1', Blockly.Python.ORDER_ATOMIC);
    var location = Blockly.Python.valueToCode(block, 'location', Blockly.Python.ORDER_ATOMIC);
    var value_io = block.getFieldValue('value_io');
    let allBlocks = block.workspace.getAllBlocks();
    let global = ""
    try {
        global = allBlocks[0].workspace.variableList.toString()
    }
    catch (e) {
        console.log(e)
    }
    // var value_count = Blockly.Python.valueToCode(block, 'count', Blockly.Python.ORDER_ATOMIC);
    Blockly.Python.definitions_['v831_import_time'] = `import time`;
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    Blockly.Python.definitions_['v831_import_CocoPi_multiFuncGpio'] = `from CocoPi import multiFuncGpio`;
    Blockly.Python.addVariable("STRIP" + value_io, `STRIP${value_io} = multiFuncGpio(${value_io - 1},7)
STRIP${value_io}.setBrightness(${value_brightness})`, true);

    Blockly.Python.addFunction("LEDSTRIPSHOW",`def LEDSTRIPSHOW(LEDCOLOR,num1,num2,brightness):

    for i in range(num1-1,num2+1):
        STRIP${value_io}.setRgbSerialColor(i-1 ,LEDCOLOR[0],LEDCOLOR[1],LEDCOLOR[2])
    STRIP${value_io}.rgbSerialShow()
    time.sleep(0.01)
`,true)
    var code = `LEDSTRIPSHOW(${value_color},${location},${location1},${value_brightness})\n`

    return code;
}

Blockly.Blocks['esp32_main_controller_led_strip_set_all'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_set_gpio)
            .appendField(new Blockly.FieldDropdown([
                ["S1", "1"],
                ["S2", "2"]
            ]), "value_io").appendField(Blockly.Msg.ledstrip_set_color_all_on);
        this.appendValueInput("color")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_color);
        this.appendValueInput("brightness")
            .setCheck(null)
            .appendField(Blockly.Msg.ledstrip_set_brightness_setup);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ESP32_LED_STRIP_COLOR);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.Esp32_Main_Controller_Led_Strip_Set_TOOLTIP.replace('%1', "CocoPi"));
    }
};


Blockly.Python['esp32_main_controller_led_strip_set_all'] = function (block) {
    var value_color = Blockly.Python.valueToCode(block, 'color', Blockly.Python.ORDER_ATOMIC);
    var value_brightness = Blockly.Python.valueToCode(block, 'brightness', Blockly.Python.ORDER_ATOMIC);
    var value_io = block.getFieldValue('value_io');
    let allBlocks = block.workspace.getAllBlocks();
    let global = ""
    try {
        global = allBlocks[0].workspace.variableList.toString()
    }
    catch (e) {
        console.log(e)
    }
    // var value_count = Blockly.Python.valueToCode(block, 'count', Blockly.Python.ORDER_ATOMIC);
    Blockly.Python.definitions_['v831_import_time'] = `import time`;
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    Blockly.Python.definitions_['v831_import_CocoPi_multiFuncGpio'] = `from CocoPi import multiFuncGpio`;
    Blockly.Python.addVariable("STRIP" + value_io, `STRIP${value_io} = multiFuncGpio(${value_io - 1},7)
STRIP${value_io}.setBrightness(${value_brightness})`, true);

    Blockly.Python.addFunction("LEDSTRIPSHOW",`def LEDSTRIPSHOW(LEDCOLOR,num1,num2,brightness):
    
    for i in range(num1-1,num2+1):
        STRIP${value_io}.setRgbSerialColor(i-1 ,LEDCOLOR[0],LEDCOLOR[1],LEDCOLOR[2])
    STRIP${value_io}.rgbSerialShow()
    time.sleep(0.01)
`,true)
    var code = `LEDSTRIPSHOW(${value_color},1,10,${value_brightness})\n`

    return code;
}

Blockly.Blocks['esp32_main_controller_led_strip_set_all_off'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_set_gpio_off)
            .appendField(new Blockly.FieldDropdown([
                ["S1", "1"],
                ["S2", "2"]
            ]), "value_io").appendField(Blockly.Msg.ledstrip_set_color_all_on);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ESP32_LED_STRIP_COLOR);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.Esp32_Main_Controller_Led_Strip_Set_TOOLTIP.replace('%1', "CocoPi"));
    }
};

Blockly.Python['esp32_main_controller_led_strip_set_all_off'] = function (block) {
    var value_io = block.getFieldValue('value_io');
    // var value_count = Blockly.Python.valueToCode(block, 'count', Blockly.Python.ORDER_ATOMIC);
    Blockly.Python.definitions_['v831_import_time'] = `import time`;
    Blockly.Python.definitions_['v831_import_sys'] = `import sys
sys.path.append("/root/")`
    Blockly.Python.definitions_['v831_import_CocoPi_multiFuncGpio'] = `from CocoPi import multiFuncGpio`;
    Blockly.Python.addVariable("STRIPOFF" + value_io, `STRIPOFF${value_io} = multiFuncGpio(${value_io - 1},7)
STRIPOFF${value_io}.setBrightness(0)`, true);

    Blockly.Python.addFunction("LEDSTRIPSHOWOFF",`def LEDSTRIPSHOWOFF(LEDCOLOR):
    for i in range(10):
        
        STRIPOFF${value_io}.setRgbSerialColor(i ,LEDCOLOR[0],LEDCOLOR[1],LEDCOLOR[2])
    STRIPOFF${value_io}.rgbSerialShow()
    time.sleep(0.01)    
`,true)
    var code = `LEDSTRIPSHOWOFF((0,0,0))\n`;
    return code;
}

Blockly.Blocks['led_strip_show_above'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.ledstrip_setup_text_show_above_set)
            .appendField(new Blockly.FieldVariable("STRIP"), "varitem")
            .appendField(Blockly.Msg.ledstrip_setup_text_show_above);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(AILEDCOLOR);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.Led_Strip_Show_Above_TOOLTIP.replace('%1', "CocoPi"));
    }
};

Blockly.Python['led_strip_show_above'] = function (block) {
    var variable_name = Blockly.Python.variableDB_.getName(block.getFieldValue('varitem'), Blockly.Variables.NAME_TYPE);
    // TODO: Assemble Python into code variable.
    var code = `${variable_name}.pixelShow()
`
    return code;
};


Blockly.Blocks['led_strip_color_rgb'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_r);
        this.appendValueInput("rgb_value_r")
            .setCheck(null)
            .appendField("");
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_g);
        this.appendValueInput("rgb_value_g")
            .setCheck(null)
            .appendField("");
        this.appendDummyInput()
            .appendField(Blockly.Msg.image_process_rgb_b);
        this.appendValueInput("rgb_value_b")
            .setCheck(null)
            .appendField("");
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(AILEDCOLOR);
        this.setTooltip(Blockly.Msg.Led_Strip_Color_Rgb_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['led_strip_color_rgb'] = function (block) {
    var value_rgb_value_r = Blockly.Python.valueToCode(block, 'rgb_value_r', Blockly.Python.ORDER_ATOMIC);
    var value_rgb_value_g = Blockly.Python.valueToCode(block, 'rgb_value_g', Blockly.Python.ORDER_ATOMIC);
    var value_rgb_value_b = Blockly.Python.valueToCode(block, 'rgb_value_b', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = '' + value_rgb_value_r + ',' + value_rgb_value_g + ',' + value_rgb_value_b + '';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};


/*
   ____                      ____           _ 
  / ___| __ _ _ __ ___   ___|  _ \ __ _  __| |
 | |  _ / _` | '_ ` _ \ / _ \ |_) / _` |/ _` |
 | |_| | (_| | | | | | |  __/  __/ (_| | (_| |
  \____|\__,_|_| |_| |_|\___|_|   \__,_|\__,_|

*/


var GAMEPAD_COLOR = "#183895";


Blockly.Blocks['x_iot_read_gamepad_button_pressed'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_iot)
            .appendField(new Blockly.FieldDropdown([
                ["X", "x"],
                ["Y", "y"],
                ["A", "a"],
                ["B", "b"],
                ["L", "l"],
                ["R", "r"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_pressed_iot);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'x': Blockly.Msg.x_iot_read_gamepad_button_pressed_TOOLTIP.replace('%1', "X"),
                'y': Blockly.Msg.x_iot_read_gamepad_button_pressed_TOOLTIP.replace('%1', "Y"),
                'a': Blockly.Msg.x_iot_read_gamepad_button_pressed_TOOLTIP.replace('%1', "A"),
                'b': Blockly.Msg.x_iot_read_gamepad_button_pressed_TOOLTIP.replace('%1', "B"),
                'l': Blockly.Msg.x_iot_read_gamepad_button_pressed_TOOLTIP.replace('%1', "L"),
                'r': Blockly.Msg.x_iot_read_gamepad_button_pressed_TOOLTIP.replace('%1', "R")
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};

Blockly.Python['x_iot_read_gamepad_button_pressed'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def_iot'] = '' +
        'from machine import ADC, Pin\n' +
        'import time\n' +
        'from machine import I2C\n' +
        'from ads1x15 import ADS1115\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_button_def_iot'] = '' +
        '_px = Pin(36, Pin.IN,Pin.PULL_UP)\n' +
        '_py = Pin(39, Pin.IN,Pin.PULL_UP)\n' +
        '_pa = Pin(4, Pin.IN,Pin.PULL_UP)\n' +
        '_pb = Pin(2, Pin.IN,Pin.PULL_UP)\n' +
        '_pl = Pin(17, Pin.IN,Pin.PULL_UP)\n' +
        '_pr = Pin(16, Pin.IN,Pin.PULL_UP)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_p' + dropdown_type + '.value() == 1';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['x_iot_read_gamepad_button_released'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_iot)
            .appendField(new Blockly.FieldDropdown([
                ["X", "x"],
                ["Y", "y"],
                ["A", "a"],
                ["B", "b"],
                ["L", "l"],
                ["R", "r"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_released_iot);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'x': Blockly.Msg.x_iot_read_gamepad_button_released_TOOLTIP.replace('%1', "X"),
                'y': Blockly.Msg.x_iot_read_gamepad_button_released_TOOLTIP.replace('%1', "Y"),
                'a': Blockly.Msg.x_iot_read_gamepad_button_released_TOOLTIP.replace('%1', "A"),
                'b': Blockly.Msg.x_iot_read_gamepad_button_released_TOOLTIP.replace('%1', "B"),
                'l': Blockly.Msg.x_iot_read_gamepad_button_released_TOOLTIP.replace('%1', "L"),
                'r': Blockly.Msg.x_iot_read_gamepad_button_released_TOOLTIP.replace('%1', "R")
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};

Blockly.Python['x_iot_read_gamepad_button_released'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def_iot'] = '' +
        'from machine import ADC, Pin\n' +
        'import time\n' +
        'from machine import I2C\n' +
        'from ads1x15 import ADS1115\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_button_def_iot'] = '' +
        '_px = Pin(36, Pin.IN,Pin.PULL_UP)\n' +
        '_py = Pin(39, Pin.IN,Pin.PULL_UP)\n' +
        '_pa = Pin(4, Pin.IN,Pin.PULL_UP)\n' +
        '_pb = Pin(2, Pin.IN,Pin.PULL_UP)\n' +
        '_pl = Pin(17, Pin.IN,Pin.PULL_UP)\n' +
        '_pr = Pin(16, Pin.IN,Pin.PULL_UP)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_p' + dropdown_type + '.value() == 0';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['x_iot_read_gamepad_button_x-r'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_button_status_first_text_iot)
            .appendField(new Blockly.FieldDropdown([
                ["X", "x"],
                ["Y", "y"],
                ["A", "a"],
                ["B", "b"],
                ["L", "l"],
                ["R", "r"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_button_status_after_text_iot);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'x': Blockly.Msg.x_iot_read_gamepad_button_xr_TOOLTIP.replace('%1', "X"),
                'y': Blockly.Msg.x_iot_read_gamepad_button_xr_TOOLTIP.replace('%1', "Y"),
                'a': Blockly.Msg.x_iot_read_gamepad_button_xr_TOOLTIP.replace('%1', "A"),
                'b': Blockly.Msg.x_iot_read_gamepad_button_xr_TOOLTIP.replace('%1', "B"),
                'l': Blockly.Msg.x_iot_read_gamepad_button_xr_TOOLTIP.replace('%1', "L"),
                'r': Blockly.Msg.x_iot_read_gamepad_button_xr_TOOLTIP.replace('%1', "R")
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};


Blockly.Python['x_iot_read_gamepad_button_x-r'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def_iot'] = '' +
        'from machine import ADC, Pin\n' +
        'import time\n' +
        'from machine import I2C\n' +
        'from ads1x15 import ADS1115\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_button_def_iot'] = '' +
        '_px = Pin(36, Pin.IN,Pin.PULL_UP)\n' +
        '_py = Pin(39, Pin.IN,Pin.PULL_UP)\n' +
        '_pa = Pin(4, Pin.IN,Pin.PULL_UP)\n' +
        '_pb = Pin(2, Pin.IN,Pin.PULL_UP)\n' +
        '_pl = Pin(17, Pin.IN,Pin.PULL_UP)\n' +
        '_pr = Pin(16, Pin.IN,Pin.PULL_UP)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_p' + dropdown_type + '.value()';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['x_iot_read_gamepad_joystick'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_joystick_read_iot)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.x_gamepad_read_joystick_read_iot_x, "X"],
                [Blockly.Msg.x_gamepad_read_joystick_read_iot_y, "Y"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_joystick_read_after_iot);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'X': Blockly.Msg.x_iot_read_gamepad_joystick_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_read_iot_x),
                'Y': Blockly.Msg.x_iot_read_gamepad_joystick_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_read_iot_y)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};


Blockly.Python['x_iot_read_gamepad_joystick'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def_iot'] = '' +
        'from machine import ADC, Pin\n' +
        'import time\n' +
        'from machine import I2C\n' +
        'from ads1x15 import ADS1115\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_joystick_def_iot'] = '' +
        '_adc_i2c = I2C(scl=Pin(22), sda=Pin(21))\n' +
        '_joystick_adc = ADS1115(_adc_i2c, 0x48, 1)\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_joystick_check_direction_def'] = '' +
        'def map_number_scale(val):\n' +
        '    return int(((val - 0) / (26400-0)) * (1023-0) + 0)\n' +
        '\n' +
        'def _read_direction():\n' +
        '    _adcX = map_number_scale(_joystick_adc.read(channel1=1))\n' +
        '    _adcY = map_number_scale(_joystick_adc.read(channel1=0))\n' +
        '    if (_adcY > 38) and (_adcY < 968) and (_adcX > 38) and (_adcX < 968):\n' +
        '        return "still"\n' +
        '    elif _adcX > 968:\n' +
        '        return "left"\n' +
        '    elif _adcX < 38:\n' +
        '        return "right"\n' +
        '    elif _adcY > 968:\n' +
        '        return "top"\n' +
        '    elif _adcY < 38:\n' +
        '        return "bottom"\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    if (dropdown_type == "X") {
        var code = 'map_number_scale(_joystick_adc.read(channel1=1))';
    } else if (dropdown_type == "Y") {
        var code = 'map_number_scale(_joystick_adc.read(channel1=0))';
    }
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['x_iot_read_gamepad_joystick_check'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_joystick_when_iot)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.x_gamepad_read_joystick_when_top_iot, "top"],
                [Blockly.Msg.x_gamepad_read_joystick_when_bottom_iot, "bottom"],
                [Blockly.Msg.x_gamepad_read_joystick_when_left_iot, "left"],
                [Blockly.Msg.x_gamepad_read_joystick_when_right_iot, "right"],
                [Blockly.Msg.x_gamepad_read_joystick_when_not_iot, "still"],
            ]), "type");
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'top': Blockly.Msg.x_iot_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_top_iot),
                'bottom': Blockly.Msg.x_iot_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_bottom_iot),
                'left': Blockly.Msg.x_iot_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_left_iot),
                'right': Blockly.Msg.x_iot_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_right_iot),
                'still': Blockly.Msg.x_iot_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_not_iot)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};


Blockly.Python['x_iot_read_gamepad_joystick_check'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def_iot'] = '' +
        'from machine import ADC, Pin\n' +
        'import time\n' +
        'from machine import I2C\n' +
        'from ads1x15 import ADS1115\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_joystick_def_iot'] = '' +
        '_adc_i2c = I2C(scl=Pin(22), sda=Pin(21))\n' +
        '_joystick_adc = ADS1115(_adc_i2c, 0x48, 1)\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_joystick_check_direction_def'] = '' +
        'def map_number_scale(val):\n' +
        '    return int(((val - 0) / (26400-0)) * (1023-0) + 0)\n' +
        '\n' +
        'def _read_direction():\n' +
        '    _adcX = map_number_scale(_joystick_adc.read(channel1=1))\n' +
        '    _adcY = map_number_scale(_joystick_adc.read(channel1=0))\n' +
        '    if (_adcY > 38) and (_adcY < 968) and (_adcX > 38) and (_adcX < 968):\n' +
        '        return "still"\n' +
        '    elif _adcX > 968:\n' +
        '        return "left"\n' +
        '    elif _adcX < 38:\n' +
        '        return "right"\n' +
        '    elif _adcY > 968:\n' +
        '        return "top"\n' +
        '    elif _adcY < 38:\n' +
        '        return "bottom"\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_read_direction() == "' + dropdown_type + '"';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};














Blockly.Blocks['x_ai_read_gamepad_button_pressed'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_ai)
            .appendField(new Blockly.FieldDropdown([
                ["X", "x"],
                ["Y", "y"],
                ["A", "a"],
                ["B", "b"],
                ["L", "l"],
                ["R", "r"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_pressed_ai);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'x': Blockly.Msg.x_ai_read_gamepad_button_pressed_TOOLTIP.replace('%1', "X"),
                'y': Blockly.Msg.x_ai_read_gamepad_button_pressed_TOOLTIP.replace('%1', "Y"),
                'a': Blockly.Msg.x_ai_read_gamepad_button_pressed_TOOLTIP.replace('%1', "A"),
                'b': Blockly.Msg.x_ai_read_gamepad_button_pressed_TOOLTIP.replace('%1', "B"),
                'l': Blockly.Msg.x_ai_read_gamepad_button_pressed_TOOLTIP.replace('%1', "L"),
                'r': Blockly.Msg.x_ai_read_gamepad_button_pressed_TOOLTIP.replace('%1', "R")
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};

Blockly.Python['x_ai_read_gamepad_button_pressed'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def'] = '' +
        'from fpioa_manager import *\n' +
        'from Maix import FPIOA, GPIO\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_button_def'] = '' +
        '_gp_side_button = [13, 14]\n' +
        '_gp_right_button = [22, 21, 15, 17]\n' +
        'FPIOA().set_function(_gp_side_button[0],FPIOA.GPIO0)\n' +
        'FPIOA().set_function(_gp_side_button[1],FPIOA.GPIO1)\n' +
        'FPIOA().set_function(_gp_right_button[0],FPIOA.GPIO2)\n' +
        'FPIOA().set_function(_gp_right_button[1],FPIOA.GPIO3)\n' +
        'FPIOA().set_function(_gp_right_button[2],FPIOA.GPIO4)\n' +
        'FPIOA().set_function(_gp_right_button[3],FPIOA.GPIO5)\n' +
        '_gp_button_l = GPIO(GPIO.GPIO0,GPIO.IN)\n' +
        '_gp_button_r = GPIO(GPIO.GPIO1,GPIO.IN)\n' +
        '_gp_button_x = GPIO(GPIO.GPIO2,GPIO.IN)\n' +
        '_gp_button_y = GPIO(GPIO.GPIO3,GPIO.IN)\n' +
        '_gp_button_a = GPIO(GPIO.GPIO4,GPIO.IN)\n' +
        '_gp_button_b = GPIO(GPIO.GPIO5,GPIO.IN)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_gp_button_' + dropdown_type + '.value() == 1';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['x_ai_read_gamepad_button_released'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_ai)
            .appendField(new Blockly.FieldDropdown([
                ["X", "x"],
                ["Y", "y"],
                ["A", "a"],
                ["B", "b"],
                ["L", "l"],
                ["R", "r"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_button_first_text_released_ai);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'x': Blockly.Msg.x_ai_read_gamepad_button_released_TOOLTIP.replace('%1', "X"),
                'y': Blockly.Msg.x_ai_read_gamepad_button_released_TOOLTIP.replace('%1', "Y"),
                'a': Blockly.Msg.x_ai_read_gamepad_button_released_TOOLTIP.replace('%1', "A"),
                'b': Blockly.Msg.x_ai_read_gamepad_button_released_TOOLTIP.replace('%1', "B"),
                'l': Blockly.Msg.x_ai_read_gamepad_button_released_TOOLTIP.replace('%1', "L"),
                'r': Blockly.Msg.x_ai_read_gamepad_button_released_TOOLTIP.replace('%1', "R")
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};

Blockly.Python['x_ai_read_gamepad_button_released'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def'] = '' +
        'from fpioa_manager import *\n' +
        'from Maix import FPIOA, GPIO\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_button_def'] = '' +
        '_gp_side_button = [13, 14]\n' +
        '_gp_right_button = [15, 17, 22, 21]\n' +
        'FPIOA().set_function(_gp_side_button[0],FPIOA.GPIO0)\n' +
        'FPIOA().set_function(_gp_side_button[1],FPIOA.GPIO1)\n' +
        'FPIOA().set_function(_gp_right_button[0],FPIOA.GPIO2)\n' +
        'FPIOA().set_function(_gp_right_button[1],FPIOA.GPIO3)\n' +
        'FPIOA().set_function(_gp_right_button[2],FPIOA.GPIO4)\n' +
        'FPIOA().set_function(_gp_right_button[3],FPIOA.GPIO5)\n' +
        '_gp_button_l = GPIO(GPIO.GPIO0,GPIO.IN)\n' +
        '_gp_button_r = GPIO(GPIO.GPIO1,GPIO.IN)\n' +
        '_gp_button_x = GPIO(GPIO.GPIO2,GPIO.IN)\n' +
        '_gp_button_y = GPIO(GPIO.GPIO3,GPIO.IN)\n' +
        '_gp_button_a = GPIO(GPIO.GPIO4,GPIO.IN)\n' +
        '_gp_button_b = GPIO(GPIO.GPIO5,GPIO.IN)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_gp_button_' + dropdown_type + '.value() == 0';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['x_ai_read_gamepad_button_x-r'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_button_status_first_text_ai)
            .appendField(new Blockly.FieldDropdown([
                ["X", "x"],
                ["Y", "y"],
                ["A", "a"],
                ["B", "b"],
                ["L", "l"],
                ["R", "r"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_button_status_after_text_ai);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'x': Blockly.Msg.x_ai_read_gamepad_button_xr_TOOLTIP.replace('%1', "X"),
                'y': Blockly.Msg.x_ai_read_gamepad_button_xr_TOOLTIP.replace('%1', "Y"),
                'a': Blockly.Msg.x_ai_read_gamepad_button_xr_TOOLTIP.replace('%1', "A"),
                'b': Blockly.Msg.x_ai_read_gamepad_button_xr_TOOLTIP.replace('%1', "B"),
                'l': Blockly.Msg.x_ai_read_gamepad_button_xr_TOOLTIP.replace('%1', "L"),
                'r': Blockly.Msg.x_ai_read_gamepad_button_xr_TOOLTIP.replace('%1', "R")
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};


Blockly.Python['x_ai_read_gamepad_button_x-r'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_all_def'] = '' +
        'from fpioa_manager import *\n' +
        'from Maix import FPIOA, GPIO\n' +
        '\n';

    Blockly.Python.definitions_['gamepad_button_def'] = '' +
        '_gp_side_button = [13, 14]\n' +
        '_gp_right_button = [15, 17, 22, 21]\n' +
        'FPIOA().set_function(_gp_side_button[0],FPIOA.GPIO0)\n' +
        'FPIOA().set_function(_gp_side_button[1],FPIOA.GPIO1)\n' +
        'FPIOA().set_function(_gp_right_button[0],FPIOA.GPIO2)\n' +
        'FPIOA().set_function(_gp_right_button[1],FPIOA.GPIO3)\n' +
        'FPIOA().set_function(_gp_right_button[2],FPIOA.GPIO4)\n' +
        'FPIOA().set_function(_gp_right_button[3],FPIOA.GPIO5)\n' +
        '_gp_button_l = GPIO(GPIO.GPIO0,GPIO.IN)\n' +
        '_gp_button_r = GPIO(GPIO.GPIO1,GPIO.IN)\n' +
        '_gp_button_x = GPIO(GPIO.GPIO2,GPIO.IN)\n' +
        '_gp_button_y = GPIO(GPIO.GPIO3,GPIO.IN)\n' +
        '_gp_button_a = GPIO(GPIO.GPIO4,GPIO.IN)\n' +
        '_gp_button_b = GPIO(GPIO.GPIO5,GPIO.IN)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_gp_button_' + dropdown_type + '.value()';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['x_ai_read_gamepad_joystick'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_joystick_read_ai)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.x_gamepad_read_joystick_read_iot_x, "0"],
                [Blockly.Msg.x_gamepad_read_joystick_read_iot_y, "1"]
            ]), "type")
            .appendField(Blockly.Msg.x_gamepad_read_joystick_read_after_ai);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                '0': Blockly.Msg.x_ai_read_gamepad_joystick_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_read_iot_x),
                '1': Blockly.Msg.x_ai_read_gamepad_joystick_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_read_iot_y)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};


Blockly.Python['x_ai_read_gamepad_joystick'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_joystick_def'] = '' +
        'from machine import I2C\n' +
        'from ads1x15 import ADS1115\n' +
        '\n' +
        '_adc_i2c = I2C(I2C.I2C0, freq=100000, scl=30, sda=29)\n' +
        '_joystick_adc = ADS1115(_adc_i2c, 0x48, 1)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = 'int(_joystick_adc.read(channel1=' + dropdown_type + ')/25.75)';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['x_ai_read_gamepad_joystick_check'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.x_gamepad_read_joystick_when_ai)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.x_gamepad_read_joystick_when_top_ai, "top"],
                [Blockly.Msg.x_gamepad_read_joystick_when_bottom_ai, "bottom"],
                [Blockly.Msg.x_gamepad_read_joystick_when_left_ai, "left"],
                [Blockly.Msg.x_gamepad_read_joystick_when_right_ai, "right"],
                [Blockly.Msg.x_gamepad_read_joystick_when_not_ai, "still"],
            ]), "type");
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(GAMEPAD_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'top': Blockly.Msg.x_ai_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_top_ai),
                'bottom': Blockly.Msg.x_ai_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_bottom_ai),
                'left': Blockly.Msg.x_ai_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_left_ai),
                'right': Blockly.Msg.x_ai_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_right_ai),
                'still': Blockly.Msg.x_ai_read_gamepad_joystick_check_TOOLTIP.replace('%1', Blockly.Msg.x_gamepad_read_joystick_when_not_ai)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};


Blockly.Python['x_ai_read_gamepad_joystick_check'] = function (block) {
    var dropdown_type = block.getFieldValue('type');

    Blockly.Python.definitions_['gamepad_joystick_def'] = '' +
        'from machine import I2C\n' +
        'from ads1x15 import ADS1115\n' +
        '\n' +
        '_adc_i2c = I2C(I2C.I2C0, freq=100000, scl=30, sda=29)\n' +
        '_joystick_adc = ADS1115(_adc_i2c, 0x48, 1)\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    '\n';

    Blockly.Python.definitions_['gamepad_joystick_check_direction_def'] = '' +
        'def _read_direction():\n' +
        '    if (int(_joystick_adc.read(channel1=0)/25.75) > 400) and (int(_joystick_adc.read(channel1=0)/25.75) < 600) and (int(_joystick_adc.read(channel1=1)/25.75) > 400) and (int(_joystick_adc.read(channel1=1)/25.75) < 600):\n' +
        '        return "still" \n' +
        '    elif int(_joystick_adc.read(channel1=1)/25.75) > 600:\n' +
        '        return "left"\n' +
        '    elif int(_joystick_adc.read(channel1=1)/25.75) < 400:\n' +
        '        return "right"\n' +
        '    elif int(_joystick_adc.read(channel1=0)/25.75) > 600:\n' +
        '        return "top"\n' +
        '    elif int(_joystick_adc.read(channel1=0)/25.75) < 400:\n' +
        '        return "bottom"\n' +
        '\n';
    // TODO: Assemble Python into code variable.
    var code = '_read_direction() == "' + dropdown_type + '"';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};


/*
     __  ___        _____     _____ 
  /\ \ \/ __\       \_   \___/__   \
 /  \/ /__\//_____   / /\/ _ \ / /\/
/ /\  / \/  \_____/\/ /_| (_) / /   
\_\ \/\_____/     \____/ \___/\/    

Blockly.Python.addVariable('', '', true);
Blockly.Python.definitions_['definition'] = '';
Blockly.Python.addSetup("setup", '');
                                    

*/

var ESP32_NBIOT_COLOR = "#629978";

Blockly.Blocks['esp32_nbiot_setup'] = {
    init: function () {
        let type = getLocalStorage("type")
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/nbiot_esp32_header.png", 110, 40, { alt: "*", flipRtl: "FALSE" }));
        type == 1 ? this.appendDummyInput()
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.nbiot_module_which_module_ai, "ai"],
                [Blockly.Msg.nbiot_module_which_module_iot, "iot"]
            ]), "module_type") : this.appendDummyInput()
                .appendField(new Blockly.FieldDropdown([
                    [Blockly.Msg.nbiot_module_which_module_iot, "iot"],
                    [Blockly.Msg.nbiot_module_which_module_ai, "ai"]
                ]), "module_type");
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_module_init);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ESP32_NBIOT_COLOR);
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('module_type');
            var TOOLTIPS = {
                'ai': Blockly.Msg.esp32_nbiot_setup_TOOLTIP.replace('%1', Blockly.Msg.nbiot_module_which_module_ai),
                'iot': Blockly.Msg.esp32_nbiot_setup_TOOLTIP.replace('%1', Blockly.Msg.nbiot_module_which_module_iot)
            };
            return TOOLTIPS[mode];
        });
        this.setHelpUrl("");
    }
};


Blockly.Python['esp32_nbiot_setup'] = function (block) {
    // TODO: Assemble Python into code variable.
    var dropdown_module_type = block.getFieldValue('module_type');

    if (dropdown_module_type == "iot") {
        Blockly.Python.addVariable('_nbiot_serial_read', '_nbiot_serial_read = ""', true);
        Blockly.Python.addVariable('_nbiot_readings', '_nbiot_readings = ""', true);
        Blockly.Python.addVariable('_nbiot_power_on_status', '_nbiot_power_on_status = False', true);
        Blockly.Python.addVariable('_nbiot_internet_status', '_nbiot_internet_status = False', true);
        Blockly.Python.addVariable('_nbiot_internet_ip_address', '_nbiot_internet_ip_address = ""', true);

        Blockly.Python.definitions_['import_definition'] = '' +
            'from machine import UART\n' +
            'from machine import Timer\n' +
            'import ubinascii as binascii\n' +
            'import time\n' +
            '\n' +
            '_nbiot_serial = UART(2,rx=16, tx=17, baudrate=115200, timeout=10)\n' +
            '\n' +
            '_nbiot_serial_timer = Timer(1)\n' +
            '_nbiot_serial_timer.init(period=50, mode=Timer.PERIODIC, callback=lambda t: _read_nbiot_serial(_nbiot_serial))\n' +
            '\n' +
            'def _read_nbiot_serial(uart):\n' +
            '    global _nbiot_readings, _nbiot_power_on_status, _nbiot_internet_status, _nbiot_internet_ip_address\n' +
            '    if _nbiot_serial.any():\n' +
            '        _nbiot_serial_read = _nbiot_serial.readline().decode("utf-8")\n' +
            '        _nbiot_serial_read = _nbiot_serial_read.strip()\n' +
            '        _nbiot_readings = _nbiot_serial_read.strip()\n' +
            '\n' +
            '        if _nbiot_serial_read == "+CPIN: READY":\n' +
            '            _nbiot_power_on_status = True\n' +
            '            print("NB-IoT Module Initiated!\\n")\n' +
            '            _nbiot_serial.write(b\'AT+CMSYSCTRL=0,2,50,300,100,800\\r\\n\')\n' +
            '\n' +
            '        if "+IP" in _nbiot_serial_read:\n' +
            '            _nbiot_internet_status = True\n' +
            '            _nbiot_internet_ip_address = _nbiot_serial_read[5:len(_nbiot_serial_read)]\n' +
            '';

        var code = '';
    } else if (dropdown_module_type == "ai") {
        Blockly.Python.addVariable('_nbiot_serial_read', '_nbiot_serial_read = ""', true);
        Blockly.Python.addVariable('_nbiot_readings', '_nbiot_readings = ""', true);
        Blockly.Python.addVariable('_nbiot_power_on_status', '_nbiot_power_on_status = False', true);
        Blockly.Python.addVariable('_nbiot_internet_status', '_nbiot_internet_status = False', true);
        Blockly.Python.addVariable('_nbiot_internet_ip_address', '_nbiot_internet_ip_address = ""', true);

        Blockly.Python.definitions_['import_definition'] = '' +
            'import machine, time\n' +
            'from fpioa_manager import fm\n' +
            'from machine import Timer\n' +
            '\n' +
            'fm.register(13,fm.fpioa.UART2_TX)\n' +
            'fm.register(14,fm.fpioa.UART2_RX)\n' +
            '\n' +
            '_nbiot_serial = machine.UART(machine.UART.UART2,115200, 8, None, 1, timeout=50)\n' +
            '\n' +
            'def _on_timer(timer):\n' +
            '    _read_nbiot_serial(_nbiot_serial)\n' +
            '\n' +
            '_periodic_tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PERIODIC, period=1, callback=_on_timer, arg=_on_timer)\n' +
            '_periodic_tim.start()\n' +
            '\n' +
            'def _read_nbiot_serial(uart):\n' +
            '    global _nbiot_readings, _nbiot_power_on_status, _nbiot_internet_status, _nbiot_internet_ip_address\n' +
            '    if _nbiot_serial.any():\n' +
            '        _nbiot_serial_read = _nbiot_serial.readline().decode("utf-8")\n' +
            '        print(_nbiot_serial_read)\n' +
            '        _nbiot_serial_read = _nbiot_serial_read.strip()\n' +
            '        _nbiot_readings = _nbiot_serial_read.strip()\n' +
            '\n' +
            '        if _nbiot_serial_read == "+CPIN: READY":\n' +
            '            _nbiot_power_on_status = True\n' +
            '            print("NB-IoT Module Initiated!\\n")\n' +
            '            _nbiot_serial.write(b\'AT+CMSYSCTRL=0,2,50,300,100,800\\r\\n\')\n' +
            '\n' +
            '        if "+IP" in _nbiot_serial_read:\n' +
            '            _nbiot_internet_status = True\n' +
            '            _nbiot_internet_ip_address = _nbiot_serial_read[5:len(_nbiot_serial_read)]\n' +
            '            print("NB-IoT is Online! Public IP is: " + str(_nbiot_internet_ip_address))\n' +
            '\n' +
            '_nbiot_serial_read = ""\n' +
            '_nbiot_readings = ""\n' +
            '_nbiot_power_on_status = False\n' +
            '_nbiot_internet_status = False\n' +
            '_nbiot_internet_ip_address = ""\n' +
            '';

        var code = '';
    }
    return code;
};


Blockly.Blocks['esp32_nbiot_get_power_status'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_module_power);
        this.setOutput(true, null);
        this.setColour(ESP32_NBIOT_COLOR);
        this.setTooltip(Blockly.Msg.esp32_nbiot_get_power_status_TOOLTIP);
        this.setHelpUrl("");
    }
};


Blockly.Python['esp32_nbiot_get_power_status'] = function (block) {
    // TODO: Assemble Python into code variable.
    var code = '_nbiot_power_on_status';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['esp32_nbiot_get_network_status'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_module_connectivity);
        this.setOutput(true, null);
        this.setColour(ESP32_NBIOT_COLOR);
        this.setTooltip(Blockly.Msg.esp32_nbiot_get_network_status_TOOLTIP);
        this.setHelpUrl("");
    }
};


Blockly.Python['esp32_nbiot_get_network_status'] = function (block) {
    // TODO: Assemble Python into code variable.
    var code = '_nbiot_internet_status';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};


Blockly.Blocks['esp32_nbiot_get_network_ip'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_module_ip);
        this.setOutput(true, null);
        this.setColour(ESP32_NBIOT_COLOR);
        this.setTooltip(Blockly.Msg.esp32_nbiot_get_network_ip_TOOLTIP);
        this.setHelpUrl("");
    }
};


Blockly.Python['esp32_nbiot_get_network_ip'] = function (block) {
    // TODO: Assemble Python into code variable.
    var code = '_nbiot_internet_ip_address';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};




Blockly.Blocks['esp32_nbiot_onenet_init'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/nbiot_onenet.png", 200, 60, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_onenet_title);
        this.appendValueInput("product_id")
            .setCheck(null)
            .appendField(Blockly.Msg.nbiot_onenet_connect_productid);
        this.appendValueInput("device_id")
            .setCheck(null)
            .appendField(Blockly.Msg.nbiot_onenet_connect_deviceid);
        this.appendValueInput("device_apikey")
            .setCheck(null)
            .appendField(Blockly.Msg.nbiot_onenet_connect_device_api);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ONENET_BLOCK_COLOR);
        this.setTooltip(Blockly.Msg.esp32_nbiot_onenet_init_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['esp32_nbiot_onenet_init'] = function (block) {
    var value_product_id = Blockly.Python.valueToCode(block, 'product_id', Blockly.Python.ORDER_ATOMIC);
    var value_device_id = Blockly.Python.valueToCode(block, 'device_id', Blockly.Python.ORDER_ATOMIC);
    var value_device_apikey = Blockly.Python.valueToCode(block, 'device_apikey', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.

    Blockly.Python.addVariable('_nbiot_onenet_product_id', '', true);
    Blockly.Python.addVariable('_nbiot_onenet_device_id', '', true);
    Blockly.Python.addVariable('_nbiot_onent_device_apikey', '', true);
    Blockly.Python.addVariable('_nbiot_onenet_connection_status', '', true);
    Blockly.Python.addVariable('_nbiot_onenet_read_anything', '', true);
    Blockly.Python.addVariable('_nbiot_onenet_init_state', '', true);


    Blockly.Python.addSetup("setup", '' +
        '_nbiot_onenet_init_state = False\n' +
        '_nbiot_onenet_connection_status = False\n' +
        '_nbiot_onenet_read_anything = False\n' +
        '_nbiot_onenet_product_id = ' + value_product_id + '\n' +
        '_nbiot_onenet_device_id = ' + value_device_id + '\n' +
        '_nbiot_onent_device_apikey = ' + value_device_apikey + '\n' +
        '\n' +
        'def _nbiot_send_onenet_data(data):\n' +
        '    _nbiot_send_message = data\n' +
        '    _nbiot_send_data_content = binascii.hexlify(_nbiot_send_message).decode("utf-8")\n' +
        '    _nbiot_send_header = ",0300" + str(hex(len(_nbiot_send_message)).split(\'x\')[-1])\n' +
        '    _nbiot_send_at_content = "AT+MQTTPUB=$dp,0,1,0," + str(len(_nbiot_send_message)+len(_nbiot_send_header[1:7].replace("0",""))) + ",0300" + str(hex(len(_nbiot_send_message)).split(\'x\')[-1]) + str(_nbiot_send_data_content)\n' +
        '    return _nbiot_send_at_content\n' +
        '\n' +
        'def _nbiot_read_onenet_data(raw_response):\n' +
        '    _nbiot_receive = raw_response\n' +
        '    if "+MQTTPUBLISH" not in raw_response:\n' +
        '        return ""\n' +
        '    elif "+MQTTPUBLISH" in raw_response:\n' +
        '        _nbiot_occur = -1\n' +
        '        for i in range(0, 6):  _nbiot_occur = _nbiot_receive.find(",", _nbiot_occur + 1)\n' +
        '        return _nbiot_receive[_nbiot_occur+1:len(_nbiot_receive)]\n' +
        '\n' +
        'def _read_nbiot_onenet(_incoming_data):\n' +
        '    global _nbiot_onenet_connection_status, _nbiot_onenet_read_anything\n' +
        '\n' +
        '    if "+MQTTOPEN: OK" in _incoming_data:\n' +
        '        _nbiot_onenet_connection_status = True\n' +
        '        # print("OneNET Connected!")\n' +
        '    if "+MQTTOPEN: FAIL" in _incoming_data:\n' +
        '        _nbiot_onenet_connection_status = False\n' +
        '        # print("OneNET Lost Connection!")\n' +
        '\n' +
        '    if "+MQTTPUBLISH" in _incoming_data:\n' +
        '        _nbiot_onenet_read_anything = True\n' +
        '    else:\n' +
        '        _nbiot_onenet_read_anything = False\n' +
        '\n' +
        '    if "+MQTTDISC" in _incoming_data:\n' +
        '        _nbiot_onenet_read_anything = False\n' +
        '        _nbiot_onenet_configuration = "AT+MQTTCFG=183.230.40.39,6002,"+_nbiot_onenet_device_id+",100,"+_nbiot_onenet_product_id+","+_nbiot_onent_device_apikey+",1,0\\r\\n"\n' +
        '        print("Enabling OneNET Connection...")\n' +
        '        _nbiot_serial.write(_nbiot_onenet_configuration.encode())\n' +
        '        time.sleep_ms(100)\n' +
        '        _nbiot_serial.write(b\'AT+MQTTOPEN=1,1,0\\r\\n\')\n' +
        '\n' +
        'def _init_onenet_connection():\n' +
        '    _nbiot_onenet_configuration = "AT+MQTTCFG=183.230.40.39,6002,"+_nbiot_onenet_device_id+",100,"+_nbiot_onenet_product_id+","+_nbiot_onent_device_apikey+",1,0\\r\\n"\n' +
        '    print("Enabling OneNET Connection...")\n' +
        '    _nbiot_serial.write(_nbiot_onenet_configuration.encode())\n' +
        '    time.sleep_ms(100)\n' +
        '    _nbiot_serial.write(b\'AT+MQTTOPEN=1,1,0\\r\\n\')\n' +
        '    time.sleep_ms(100)\n' +
        '');

    var code = '' +
        'if (_nbiot_internet_status == True) and (_nbiot_onenet_init_state == False) and (_nbiot_onenet_connection_status == False):\n' +
        '    _init_onenet_connection()\n' +
        '    _nbiot_onenet_init_state = True\n' +
        '\n' +
        '_read_nbiot_onenet(_nbiot_readings)\n' +
        '';
    return code;
};


Blockly.Blocks['esp32_nbiot_onenet_connection_status'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_onenet_connectivity);
        this.setOutput(true, null);
        this.setColour(ONENET_BLOCK_COLOR);
        this.setTooltip(Blockly.Msg.esp32_nbiot_onenet_connection_status_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['esp32_nbiot_onenet_connection_status'] = function (block) {
    // TODO: Assemble Python into code variable.
    var code = '_nbiot_onenet_connection_status';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};



Blockly.Blocks['iot_service_nbiot_onenet'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/nbiot_onenet_send.png", 210, 60, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_onenet_send_title);
        /*this.appendValueInput("first_input")
            .setCheck(null)
            .appendField("Field 0");*/
        this.itemCount_ = 1;
        this.updateShape_();
        this.setMutator(new Blockly.Mutator(['iot_service_nbiot_onenet_create_with_item']));
        this.setColour(ONENET_BLOCK_COLOR);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setTooltip(Blockly.Msg.iot_service_nbiot_onenet_TOOLTIP);
        this.setHelpUrl("");
    },
    mutationToDom: function () {
        var container = document.createElement('mutation');
        container.setAttribute('items', this.itemCount_);
        return container;
    },
    domToMutation: function (xmlElement) {
        this.itemCount_ = parseInt(xmlElement.getAttribute('items'), 10);
        this.updateShape_();
    },
    decompose: function (workspace) {
        var containerBlock = workspace.newBlock('iot_service_nbiot_onenet_create_with_container');
        containerBlock.initSvg();
        var connection = containerBlock.getInput('STACK').connection;
        for (var i = 0; i < this.itemCount_; i++) {
            var itemBlock = workspace.newBlock('iot_service_nbiot_onenet_create_with_item');
            itemBlock.initSvg();
            connection.connect(itemBlock.previousConnection);
            connection = itemBlock.nextConnection;
        }
        return containerBlock;
    },
    compose: function (containerBlock) {
        var itemBlock = containerBlock.getInputTargetBlock('STACK');
        // Count number of inputs.
        var connections = [];
        while (itemBlock) {
            connections.push(itemBlock.valueConnection_);
            itemBlock = itemBlock.nextConnection &&
                itemBlock.nextConnection.targetBlock();
        }
        // Disconnect any children that don't belong.
        for (var i = 0; i < this.itemCount_; i++) {
            var connection = this.getInput('ADD' + i).connection.targetConnection;
            if (connection && connections.indexOf(connection) == -1) {
                connection.disconnect();
            }
        }
        this.itemCount_ = connections.length;
        this.updateShape_();
        // Reconnect any child blocks.
        for (var i = 0; i < this.itemCount_; i++) {
            Blockly.Mutator.reconnect(connections[i], this, 'ADD' + i);
        }
    },
    saveConnections: function (containerBlock) {
        var itemBlock = containerBlock.getInputTargetBlock('STACK');
        var i = 0;
        while (itemBlock) {
            var input = this.getInput('ADD' + i);
            itemBlock.valueConnection_ = input && input.connection.targetConnection;
            i++;
            itemBlock = itemBlock.nextConnection &&
                itemBlock.nextConnection.targetBlock();
        }
    },
    updateShape_: function () {
        for (var i = 0; i < this.itemCount_; i++) {
            if (!this.getInput('ADD' + i)) {
                var input = this.appendValueInput('ADD' + i);
                input.appendField(Blockly.Msg.nbiot_onenet_send_property)
                    .appendField(new Blockly.FieldTextInput("Property" + i), "field" + i);
                //input.appendField("資料 " + (i + 1) + ":");
                //input.appendField(new Blockly.FieldLabelSerializable("field" + (i + 1)), 'FIELD' + i);
                // input.appendField(new Blockly.FieldTextInput("資料" + (i + 1)), 'FIELD' + i)
            }
        }
        while (this.getInput('ADD' + i)) {
            this.removeInput('ADD' + i);
            i++;
        }
    },
};

Blockly.Blocks['iot_service_nbiot_onenet_create_with_container'] = {
    init: function () {
        this.setColour(ONENET_BLOCK_COLOR);
        this.appendDummyInput()
            .appendField("Items");
        this.appendStatementInput('STACK');
        this.setTooltip('');
        this.contextMenu = false;
    }
};

Blockly.Blocks['iot_service_nbiot_onenet_create_with_item'] = {
    init: function () {
        this.setColour(ONENET_BLOCK_COLOR);
        this.appendDummyInput()
            .appendField("Field");
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setTooltip('');
        this.contextMenu = false;
    }
};

Blockly.Python['iot_service_nbiot_onenet'] = function (block) {

    // var key = Blockly.Arduino.valueToCode(block, 'KEY', Blockly.Arduino.ORDER_ATOMIC).replace(/\"/g, '') || "";

    var item_field = '',
        item_value = '';
    var nbiot_onenet_data = "'{";
    for (var n = 0; n < this.itemCount_; n++) {
        item_field = block.getFieldValue("field" + n);
        item_value = Blockly.Python.valueToCode(this, 'ADD' + n, Blockly.Python.ORDER_NONE) || '';
        nbiot_onenet_data += '"' + item_field + '":"\' + str(' + item_value + ') + \'",';
    }
    var nbiot_onenet_data_final = nbiot_onenet_data + "}'";

    var code = '' +
        '_data_to_be_send = ' + nbiot_onenet_data_final.slice(0, -3) + '}\\r\\n\'' + '\n' +
        '_data_add_rn = _nbiot_send_onenet_data(_data_to_be_send) + "\\r\\n"\n' +
        '_data_for_at = _data_add_rn.encode()\n' +
        '_nbiot_serial.write(_data_for_at)\n' +
        // '_nbiot_serial.write(_nbiot_send_onenet_data(_data_to_be_send).encode())\n' +
        '\n' +
        '';

    return code;
};


Blockly.Blocks['iot_service_nbiot_onenet_read'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_onenet_when_incoming_msg);
        this.appendValueInput("message")
            .setCheck(null);
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_onenet_when_incoming_msg_when);
        this.appendStatementInput("exec")
            .setCheck(null)
            .appendField(Blockly.Msg.nbiot_onenet_when_incoming_msg_exec);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(ONENET_BLOCK_COLOR);
        this.setTooltip(Blockly.Msg.iot_service_nbiot_onenet_read_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_service_nbiot_onenet_read'] = function (block) {
    var value_message = Blockly.Python.valueToCode(block, 'message', Blockly.Python.ORDER_ATOMIC);
    var statements_exec = Blockly.Python.statementToCode(block, 'exec');
    // TODO: Assemble Python into code variable.
    var code = 'if (_nbiot_read_onenet_data(_nbiot_readings) == ' + value_message + '):\n' +
        statements_exec +
        '\n';
    return code;
};


Blockly.Blocks['esp32_nbiot_onenet_read_value'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_onenet_receive_command);
        this.setOutput(true, null);
        this.setColour(ONENET_BLOCK_COLOR);
        this.setTooltip(Blockly.Msg.esp32_nbiot_onenet_read_value_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['esp32_nbiot_onenet_read_value'] = function (block) {
    // TODO: Assemble Python into code variable.
    var code = '_nbiot_read_onenet_data(_nbiot_readings)';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};




Blockly.Blocks['iot_service_nbiot_cococloud_read'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/nbiot_cococloud_get.png", 260, 60, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_cococloud_get_event_title);
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_cococloud_get_event_api)
            .appendField(new Blockly.FieldTextInput("ENTER_YOUR_EVENT_API_KEY"), "t_api");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour(COCOCLOUD_BLOCK_COLOR);
        this.setTooltip("");
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_service_nbiot_cococloud_read'] = function (block) {
    var api = block.getFieldValue('t_api');
    // TODO: Assemble Python into code variable.
    var code = '\n';
    return code;
};


Blockly.Blocks['iot_service_nbiot_cococloud_read_data'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_cococloud_get_property);
        this.appendValueInput("property")
            .setCheck(null);
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_cococloud_get_data);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour(COCOCLOUD_BLOCK_COLOR);
        this.setTooltip("");
        this.setHelpUrl("");
    }
};

Blockly.Python['iot_service_nbiot_cococloud_read_data'] = function (block) {
    var property = Blockly.Python.valueToCode(block, 'property', Blockly.Python.ORDER_ATOMIC);
    // TODO: Assemble Python into code variable.
    var code = '\n';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};


Blockly.Blocks['iot_service_nbiot_cococloud'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/nbiot_cococloud_send.png", 260, 60, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_cococloud_send_title);
        this.appendDummyInput()
            .appendField(Blockly.Msg.nbiot_cococloud_send_api)
            .appendField(new Blockly.FieldTextInput("ENTER_YOUR_EVENT_API_KEY"), "t_api");
        /*this.appendValueInput("first_input")
            .setCheck(null)
            .appendField("Field 0");*/
        this.itemCount_ = 1;
        this.updateShape_();
        this.setMutator(new Blockly.Mutator(['iot_service_nbiot_cococloud_create_with_item']));
        this.setColour(COCOCLOUD_BLOCK_COLOR);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setTooltip(Blockly.Msg.iot_service_nbiot_cococloud_TOOLTIP);
        this.setHelpUrl("");
    },
    mutationToDom: function () {
        var container = document.createElement('mutation');
        container.setAttribute('items', this.itemCount_);
        return container;
    },
    domToMutation: function (xmlElement) {
        this.itemCount_ = parseInt(xmlElement.getAttribute('items'), 10);
        this.updateShape_();
    },
    decompose: function (workspace) {
        var containerBlock = workspace.newBlock('iot_service_nbiot_cococloud_create_with_container');
        containerBlock.initSvg();
        var connection = containerBlock.getInput('STACK').connection;
        for (var i = 0; i < this.itemCount_; i++) {
            var itemBlock = workspace.newBlock('iot_service_nbiot_cococloud_create_with_item');
            itemBlock.initSvg();
            connection.connect(itemBlock.previousConnection);
            connection = itemBlock.nextConnection;
        }
        return containerBlock;
    },
    compose: function (containerBlock) {
        var itemBlock = containerBlock.getInputTargetBlock('STACK');
        // Count number of inputs.
        var connections = [];
        while (itemBlock) {
            connections.push(itemBlock.valueConnection_);
            itemBlock = itemBlock.nextConnection &&
                itemBlock.nextConnection.targetBlock();
        }
        // Disconnect any children that don't belong.
        for (var i = 0; i < this.itemCount_; i++) {
            var connection = this.getInput('ADD' + i).connection.targetConnection;
            if (connection && connections.indexOf(connection) == -1) {
                connection.disconnect();
            }
        }
        this.itemCount_ = connections.length;
        this.updateShape_();
        // Reconnect any child blocks.
        for (var i = 0; i < this.itemCount_; i++) {
            Blockly.Mutator.reconnect(connections[i], this, 'ADD' + i);
        }
    },
    saveConnections: function (containerBlock) {
        var itemBlock = containerBlock.getInputTargetBlock('STACK');
        var i = 0;
        while (itemBlock) {
            var input = this.getInput('ADD' + i);
            itemBlock.valueConnection_ = input && input.connection.targetConnection;
            i++;
            itemBlock = itemBlock.nextConnection &&
                itemBlock.nextConnection.targetBlock();
        }
    },
    updateShape_: function () {
        for (var i = 0; i < this.itemCount_; i++) {
            if (!this.getInput('ADD' + i)) {
                var input = this.appendValueInput('ADD' + i);
                input.appendField(Blockly.Msg.nbiot_cococloud_send_property)
                    .appendField(new Blockly.FieldTextInput("Property" + i), "field" + i);
                //input.appendField("資料 " + (i + 1) + ":");
                //input.appendField(new Blockly.FieldLabelSerializable("field" + (i + 1)), 'FIELD' + i);
                // input.appendField(new Blockly.FieldTextInput("資料" + (i + 1)), 'FIELD' + i)
            }
        }
        while (this.getInput('ADD' + i)) {
            this.removeInput('ADD' + i);
            i++;
        }
    },
};

Blockly.Blocks['iot_service_nbiot_cococloud_create_with_container'] = {
    init: function () {
        this.setColour(ESP32_NBIOT_COLOR);
        this.appendDummyInput()
            .appendField("Items");
        this.appendStatementInput('STACK');
        this.setTooltip('');
        this.contextMenu = false;
    }
};

Blockly.Blocks['iot_service_nbiot_cococloud_create_with_item'] = {
    init: function () {
        this.setColour(COCOCLOUD_BLOCK_COLOR);
        this.appendDummyInput()
            .appendField("Field");
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setTooltip('');
        this.contextMenu = false;
    }
};

Blockly.Python['iot_service_nbiot_cococloud'] = function (block) {
    var api = block.getFieldValue('t_api');

    Blockly.Python.addVariable('_nbiot_cococloud_send_init_state', '', true);
    Blockly.Python.addVariable('_nbiot_cococloud_json_content', '', true);

    Blockly.Python.definitions_['import'] = '' +
        '_nbiot_cococloud_send_init_state = False\n' +
        '\n' +
        'def _nbiot_cococloud_send(data):\n' +
        '    _nbiot_cococloud_send_data = \'AT+HTTPCONTENT=0,\"\'+ data + \'\"\\r\\n\'\n' +
        '    print(_nbiot_cococloud_send_data)\n' +
        '    _nbiot_serial.write(b\'AT+HTTPCLOSE=0\\r\\n\')\n' +
        '    time.sleep_ms(500)\n' +
        '    _nbiot_serial.write(b\'AT+HTTPCREATE=\"http://api.cocorobo.hk/\"\\r\\n\')\n' +
        '    time.sleep_ms(500)\n' +
        '    _nbiot_serial.write(b\'AT+HTTPHEADER=0,\"Content-Type: application/json\\\\r\\\\n\"\\r\\n\')\n' +
        '    time.sleep_ms(500)\n' +
        '    _nbiot_serial.write(_nbiot_cococloud_send_data.encode())\n' +
        '    time.sleep_ms(500)\n' +
        '    _nbiot_serial.write(b\'AT+HTTPSEND=0,1,\"/iot/data/eventAPIKey/' + api + '\"\\r\\n\')\n' +
        '    time.sleep_ms(500)\n' +
        '';


    var item_field = '',
        item_value = '';
    var nbiot_cococloud_data = "'{";
    for (var n = 0; n < this.itemCount_; n++) {
        item_field = block.getFieldValue("field" + n);
        item_value = Blockly.Python.valueToCode(this, 'ADD' + n, Blockly.Python.ORDER_NONE) || '';
        nbiot_cococloud_data += '"' + item_field + '":"\' + str(' + item_value + ') + \'",';
    }
    var nbiot_cococloud_data_final = nbiot_cococloud_data + "}'";
    var code = '' +
        '_nbiot_cococloud_json_content = ' + nbiot_cococloud_data_final.slice(0, -3) + '}\'' + '\n' +
        '_nbiot_cococloud_send(_nbiot_cococloud_json_content)\n' +
        '';

    return code;
};










Blockly.Blocks['3rd_party_sensor_hcsr04'] = {
    init: function () {
        let types = getLocalStorage("type")
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/ultrasonic_setup_header.png", 120, 40, { alt: "*", flipRtl: "FALSE" }));
        types == 1 ? this.appendDummyInput()
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.third_party_hcsr04_ai, "ai"],
                [Blockly.Msg.third_party_hcsr04_iot, "iot"]
            ]), "type")
            .appendField(Blockly.Msg.third_party_hcsr04_setup_title)
            .appendField(new Blockly.FieldDropdown([
                ["1", "1"],
                ["2", "2"],
                ["3", "3"]
            ]), "index") : this.appendDummyInput()
                .appendField(new Blockly.FieldDropdown([
                    [Blockly.Msg.third_party_hcsr04_iot, "iot"],
                    [Blockly.Msg.third_party_hcsr04_ai, "ai"]
                ]), "type")
                .appendField(Blockly.Msg.third_party_hcsr04_setup_title)
                .appendField(new Blockly.FieldDropdown([
                    ["1", "1"],
                    ["2", "2"],
                    ["3", "3"]
                ]), "index");
        types == 1 ? this.appendDummyInput()
            .appendField(Blockly.Msg.third_party_hcsr04_trig_pin)
            .appendField(new Blockly.FieldNumber(2, 0, 40, 1), "trig")
            .appendField(Blockly.Msg.third_party_hcsr04_echo_pin)
            .appendField(new Blockly.FieldNumber(3, 0, 40, 1), "echo") :
            this.appendDummyInput()
                .appendField(Blockly.Msg.third_party_hcsr04_trig_pin)
                .appendField(new Blockly.FieldNumber(12, 0, 40, 1), "trig")
                .appendField(Blockly.Msg.third_party_hcsr04_echo_pin)
                .appendField(new Blockly.FieldNumber(13, 0, 40, 1), "echo");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour("#d72bd5");
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('type');
            var TOOLTIPS = {
                'ai': Blockly.Msg.Trd_Party_Sensor_Hcsr04_TOOLTIP.replace('%1', Blockly.Msg.third_party_hcsr04_ai),
                'iot': Blockly.Msg.Trd_Party_Sensor_Hcsr04_TOOLTIP.replace('%1', Blockly.Msg.third_party_hcsr04_iot)
            };
            return TOOLTIPS[mode];
        });
    }
};


Blockly.Python['3rd_party_sensor_hcsr04'] = function (block) {
    var dropdown_type = block.getFieldValue('type');
    var dropdown_index = block.getFieldValue('index');
    var number_trig = block.getFieldValue('trig');
    var number_echo = block.getFieldValue('echo');
    // TODO: Assemble Python into code variable.
    if (dropdown_type == "iot") {
        Blockly.Python.definitions_['import_hcsr04_def_' + number_trig + number_echo] = '' +
            'from HCSR04 import HCSR04\n' +
            'from machine import Pin\n' +
            'import time\n' +
            '\n' +
            '_ultrasonic_sensor_trig_' + number_trig + ' = Pin(' + number_trig + ',Pin.OUT)\n' +
            '_ultrasonic_sensor_echo_' + number_echo + ' = Pin(' + number_echo + ',Pin.IN)\n' +
            '_ultrasonic_sensor_read_' + dropdown_index + ' = HCSR04(_ultrasonic_sensor_trig_' + number_trig + ',_ultrasonic_sensor_echo_' + number_echo + ')\n' +
            '\n';
        var code = '';
    } else if (dropdown_type == "ai") {
        Blockly.Python.definitions_['import_hcsr04_def_' + number_trig + number_echo] = '' +
            'from HCSR04 import HCSR04\n' +
            'from fpioa_manager import *\n' +
            'from Maix import GPIO\n' +
            'import time\n' +
            '\n' +
            'fm.register(' + number_trig + ',fm.fpioa.GPIOHS' + number_trig + ')\n' +
            'fm.register(' + number_echo + ',fm.fpioa.GPIOHS' + number_echo + ')\n' +
            '\n' +
            '_ultrasonic_sensor_trig_' + number_trig + ' = GPIO(GPIO.GPIOHS' + number_trig + ', GPIO.OUT)\n' +
            '_ultrasonic_sensor_echo_' + number_echo + ' = GPIO(GPIO.GPIOHS' + number_echo + ', GPIO.IN)\n' +
            '_ultrasonic_sensor_read_' + dropdown_index + ' = HCSR04(_ultrasonic_sensor_trig_' + number_trig + ',_ultrasonic_sensor_echo_' + number_echo + ')\n' +
            '\n';
        var code = '';
    }
    return code;
};



Blockly.Blocks['3rd_party_sensor_hcsr04_read'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.third_party_hcsr04_read_text)
            .appendField(new Blockly.FieldDropdown([
                ["1", "1"],
                ["2", "2"],
                ["3", "3"]
            ]), "index")
            .appendField(Blockly.Msg.third_party_hcsr04_read_text_after);
        this.setOutput(true, null);
        this.setColour("#d72bd5");
        this.setTooltip(Blockly.Msg.Trd_Party_Sensor_Hcsr04_Read_TOOLTIP);
        this.setHelpUrl("");
    }
};


Blockly.Python['3rd_party_sensor_hcsr04_read'] = function (block) {
    var dropdown_index = block.getFieldValue('index');
    // TODO: Assemble Python into code variable.
    var code = '_ultrasonic_sensor_read_' + dropdown_index + '.getDistance()';
    // TODO: Change ORDER_NONE to the correct strength.
    return [code, Blockly.Python.ORDER_NONE];
};


Blockly.Blocks['Pedometer_Init'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.Pedometer_Init);
        this.appendValueInput("time")
            .setCheck(null)
            .appendField(Blockly.Msg.Pedometer_Init_time);
        this.appendValueInput("sensitivity")
            .setCheck(null)
            .appendField(Blockly.Msg.Pedometer_Init_sensitivity);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour("#d42b03");
        this.setTooltip(Blockly.Msg.Pedometer_Init_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['Pedometer_Init'] = function (block) {
    var time = Blockly.Python.valueToCode(block, 'time', Blockly.Python.ORDER_ATOMIC);
    var sensitivity = Blockly.Python.valueToCode(block, 'sensitivity', Blockly.Python.ORDER_ATOMIC);

    Blockly.Python.definitions_['Pedometer_Init'] = `from machine import I2C, Pin
import math
import QMI8658

mpu_lib_version_is_latest = "QMI8658" in dir(QMI8658)
if mpu_lib_version_is_latest == True:
    mpui2c = I2C(scl=Pin(22), sda=Pin(21))
    QMI8658 = QMI8658.QMI8658(mpui2c)
    mpucal = QMI8658.calibrate()
elif mpu_lib_version_is_latest == False:
    #申明QMI8658传感器IIC通信引脚
    _SENSOR_MPU_PINS = I2C(scl=Pin(22), sda=Pin(21))
    _MPU = QMI8658.accel(_SENSOR_MPU_PINS)
    _MPU_SHAKING_OFFSET = _MPU.get_values()['AcZ']
    _MPU_ACCL_X = _MPU.get_values()['AcX']
    _MPU_ACCL_Y = _MPU.get_values()['AcY']
    _MPU_ACCL_Z = _MPU.get_values()['AcZ']
    _MPU_OFFSET_TILT_X = _MPU_GET_TILT_ANGLE('X')
    _MPU_OFFSET_TILT_Y = _MPU_GET_TILT_ANGLE('Y')
    _MPU_OFFSET_TILT_Z = _MPU_GET_TILT_ANGLE('Z')

threshold_time=`+ time + `     #时间筛选阈值
threshold_hill=`+ sensitivity + `     #波峰波谷差值阈值
xval=[None]*100         #初始X轴加速度原始数据采集列表
yval=[None]*100         #初始Y轴加速度原始数据采集列表
zval=[None]*100         #初始Z轴加速度原始数据采集列表
xavg=0                  #X轴方向初始加速度平均值
yavg=0                  #Y轴方向初始加速度平均值
zavg=0                  #Z轴方向初始加速度平均值
xaccl=[None]*100        #X轴加速度实时采集列表
yaccl=[None]*100        #Y轴加速度实时采集列表
zaccl=[None]*100        #Z轴加速度实时采集列表
totvect=[0.0]*100       #三个方向总加速度矢量值
totave=[0.0]*100        #最大和最小加速度矢量值平均值
peak=0                  #波峰数据
trough=0                #波谷数据
data=[0]*15             #实时采集数据滚动递进列表
steps=0                 #行走步伐数
flag0=0                 #步数提取标志位
flag1=0                 #波峰提取标志位
flag2=0                 #波谷提取标志位
hill=0                  #波峰波谷差值
starttime=0             #波峰时间点
endtime=0               #波谷时间点
lasttime=0              #波峰波谷间隔时间


#获取三个方向加速度函数
def QMI8658_get_accel(type):
    _MPU = QMI8658.accel(_SENSOR_MPU_PINS)
    _MPU_SHAKING_OFFSET = _MPU.get_values()['AcZ']
    _MPU_ACCL_X = _MPU.get_values()['AcX']
    _MPU_ACCL_Y = _MPU.get_values()['AcY']
    _MPU_ACCL_Z = _MPU.get_values()['AcZ']
    _MPU_OFFSET_TILT_X = _MPU_GET_TILT_ANGLE('X')
    _MPU_OFFSET_TILT_Y = _MPU_GET_TILT_ANGLE('Y')
    _MPU_OFFSET_TILT_Z = _MPU_GET_TILT_ANGLE('Z')
    if type == 'X':
        return _MPU_ACCL_X
    if type == 'Y':
        return _MPU_ACCL_Y
    if type == 'Z':
        return _MPU_ACCL_Z

#初始化校准函数
def calibration():
    sum0=0          #x轴加速度累计值
    sum1=0          #y轴加速度累计值
    sum2=0          #z轴加速度累计值
    for i in range(100):
        xval[i]= QMI8658.read(mpucal)['AcX']-345 if mpu_lib_version_is_latest == True else QMI8658_get_accel('X')-345
        sum0=xval[i]+sum0
    time.sleep_ms(100)
    xavg=sum0/100
    #print(xavg)
    for i in range(100):
        yval[i]= QMI8658.read(mpucal)['AcY']-346 if mpu_lib_version_is_latest == True else QMI8658_get_accel('Y')-346
        sum1=yval[i]+sum1
    time.sleep_ms(100)
    yavg=sum1/100
    #print(yavg)
    for i in range(100):
        zval[i]= QMI8658.read(mpucal)['AcZ']-416 if mpu_lib_version_is_latest == True else QMI8658_get_accel('Z')-416
        sum2=zval[i]+sum2
    time.sleep_ms(100)
    zavg=sum2/100
    #print(zavg)

def getPedometer():
    global q, xaccl, yaccl, zaccl, totvect, totave, data, peak, flag0, flag1, flag2, starttime, lasttime, endtime, hill, trough, threshold_hill, hill, threshold_time, steps
    for a in range(100):
        xaccl[a]= QMI8658.read(mpucal)['AcX']-345 if mpu_lib_version_is_latest == True else QMI8658_get_accel('X')-345
        time.sleep_ms(1)
        yaccl[a]= QMI8658.read(mpucal)['AcY']-346 if mpu_lib_version_is_latest == True else QMI8658_get_accel('Y')-346
        time.sleep_ms(1)
        zaccl[a]= QMI8658.read(mpucal)['AcZ']-416 if mpu_lib_version_is_latest == True else QMI8658_get_accel('Z')-416
        time.sleep_ms(1)
        #计算X、Y、Z轴三个方向加速度值的平方根来计算总加速度矢量
        totvect[a]=math.sqrt(((xaccl[a]-xavg)*(xaccl[a]-xavg))+((yaccl[a]-yavg)*(yaccl[a]-yavg))+((zaccl[a]-zavg)*(zaccl[a]-zavg)))
        totave[a]=(totvect[a]+totave[a-1])/2
        q=totave[a]
        #数据轮替
        data[2]=data[1]
        data[1]=data[0]
        data[0]=totave[a]
        #检测是否到达一个波峰，如果是，将波峰数据采集标志位置1，并开始计时
        if ((data[1]>data[0])&(data[1]>data[2])&(flag1==0)):
            peak=data[1]
            flag1=1
            starttime=time.ticks_ms()
        #检测是否到达一个波谷，如果是，将波谷数据采集标志位置1，并读取当前时间
        if ((data[1]<data[0])&(data[1]<data[2])&(flag2==0)):
            trough=data[1]
            flag2=1
            endtime=time.ticks_ms()
        #如果采集到一组波峰波谷数据
        if((flag1==1)&(flag2==1)):
            flag1=0                             #将波峰数据采集标志位置0
            flag2=0                             #将波谷数据采集标指位置1
            hill=peak-trough                    #计算波峰波谷差值
            lasttime=endtime-starttime          #计算波峰波谷间隔时间
            if(hill>threshold_hill)&(lasttime>threshold_time):       #如果波峰波谷差值大于threshold_hill且间隔时间大于threshold_time
                steps=steps+1                   #步数加一
                flag0=1                         #将步数数据提取标志位置1
            lasttime=0                          #将波峰波谷间隔时间清零
            hill=0                              #将波峰波谷差值清零
        time.sleep_ms(20)
        return steps
`;

    var code = "";
    return code;
};


Blockly.Blocks['Pedometer_Run'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.Pedometer_Run);
        this.setInputsInline(false);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setColour("#d42b03");
        this.setTooltip(Blockly.Msg.Pedometer_Run_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['Pedometer_Run'] = function (block) {
    var code = `
calibration()
`;
    return code;
};

Blockly.Blocks['Pedometer_Get'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.Pedometer_Get);
        this.setInputsInline(true);
        this.setOutput(true, null);
        this.setColour("#d42b03");
        this.setTooltip(Blockly.Msg.Pedometer_Get_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['Pedometer_Get'] = function (block) {
    var code = `getPedometer()`;
    return [code, Blockly.Python.ORDER_NONE];
};


/* mlx90614 */

Blockly.Blocks['mlx90614_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/body_temp_mlx.png", 220, 60, { alt: "*", flipRtl: "FALSE" }));
        let types = getLocalStorage("type")
        types == 1 ? this.appendDummyInput()
            .appendField("")
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.time_ai_module, "2"],
                [Blockly.Msg.time_iot_module, "1"]
            ]), "digital_get_type")
            .appendField(Blockly.Msg.MLX90614_SETUP_TEXT_1) :
            this.appendDummyInput()
                .appendField("")
                .appendField(new Blockly.FieldDropdown([
                    [Blockly.Msg.time_iot_module, "1"],
                    [Blockly.Msg.time_ai_module, "2"]
                ]), "digital_get_type")
                .appendField(Blockly.Msg.MLX90614_SETUP_TEXT_1);
        this.appendDummyInput()
            .appendField(Blockly.Msg.MLX90614_SETUP_TEXT_2);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setInputsInline(false);
        this.setColour("#5c42bd");
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('digital_get_type');
            var TOOLTIPS = {
                '2': Blockly.Msg.MLX90614_SETUP_TOOLTIP.replace('%1', Blockly.Msg.time_ai_module),
                '1': Blockly.Msg.MLX90614_SETUP_TOOLTIP.replace('%1', Blockly.Msg.time_iot_module)
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['mlx90614_setup'] = function (block) {
    var dropdown_type = block.getFieldValue('digital_get_type');
    if (dropdown_type == "1") {
        Blockly.Python.definitions_['import_iot_mlx90614_setup'] = '' +
            'import mlx90614\n' +
            'from machine import I2C, Pin\n' +
            'import time\n' +
            '\n' +
            'def mlx90614_init():\n' +
            '    global sensor_mlx90614\n' +
            '    i2c = I2C(scl=Pin(22), sda=Pin(21),freq=100000)\n' +
            '    while True:\n' +
            '        init_success = False\n' +
            '        try:\n' +
            '            sensor_mlx90614 = mlx90614.MLX90614(i2c)\n' +
            '            init_success = True\n' +
            '        except BaseException as e:\n' +
            '            print(e)\n' +
            '        if init_success == True:\n' +
            '            break\n' +
            '\n' +
            'def mlx90614_read(datatype):\n' +
            '    read_from_mlx90614 = None\n' +
            '    try:\n' +
            '        if datatype == "read_ambient_tempC":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_ambient_tempC()\n' +
            '        elif datatype == "read_ambient_tempF":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_ambient_tempF()\n' +
            '        elif datatype == "read_object_tempC":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_object_tempC()\n' +
            '        elif datatype == "read_object_tempF":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_object_tempF()\n' +
            '    except BaseException as e:\n' +
            '        read_from_mlx90614 = None\n' +
            '        print(e)\n' +
            '    read_from_mlx90614 = round(read_from_mlx90614, 2)\n' +
            '    # print(type(read_from_mlx90614))\n' +
            '    return read_from_mlx90614\n' +
            '\n';
        var code = 'mlx90614_init()\n';
    } else if (dropdown_type == "2") {
        Blockly.Python.definitions_['import_ai_mlx90614_setup'] = '' +
            'import mlx90614\n' +
            'from machine import I2C\n' +
            'import time\n' +
            '\n' +
            'def mlx90614_init():\n' +
            '    global sensor_mlx90614\n' +
            '    i2c = I2C(I2C.I2C0, freq=100000, scl=30, sda=29)\n' +
            '    while True:\n' +
            '        init_success = False\n' +
            '        try:\n' +
            '            sensor_mlx90614 = mlx90614.MLX90614(i2c)\n' +
            '            init_success = True\n' +
            '        except BaseException as e:\n' +
            '            print(e)\n' +
            '        if init_success == True:\n' +
            '            break\n' +
            '\n' +
            'def mlx90614_read(datatype):\n' +
            '    read_from_mlx90614 = None\n' +
            '    try:\n' +
            '        if datatype == "read_ambient_tempC":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_ambient_tempC()\n' +
            '        elif datatype == "read_ambient_tempF":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_ambient_tempF()\n' +
            '        elif datatype == "read_object_tempC":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_object_tempC()\n' +
            '        elif datatype == "read_object_tempF":\n' +
            '            read_from_mlx90614 = sensor_mlx90614.read_object_tempF()\n' +
            '    except BaseException as e:\n' +
            '        read_from_mlx90614 = None\n' +
            '        print(e)\n' +
            '    read_from_mlx90614 = round(read_from_mlx90614, 2)\n' +
            '    # print(type(read_from_mlx90614))\n' +
            '    return read_from_mlx90614\n' +
            '\n';
        var code = 'mlx90614_init()\n';
    }
    return code;
};

Blockly.Blocks['mlx90614_read_ambient'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.MLX90614_READ_AMBIENT);
        this.appendDummyInput()
            .appendField(Blockly.Msg.MLX90614_READ_SET_TEMP)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.MLX90614_READ_SET_TEMP_C, "C"],
                [Blockly.Msg.MLX90614_READ_SET_TEMP_F, "F"]
            ]), "type");
        this.setInputsInline(false);
        this.setOutput(true, null);
        this.setColour("#5c42bd");
        this.setTooltip(Blockly.Msg.MLX90614_READ_AMBIENT_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['mlx90614_read_ambient'] = function (block) {
    var dropdown_type = block.getFieldValue('type');
    if (dropdown_type == "C") {
        var code = `mlx90614_read("read_ambient_tempC")`;
    } else if (dropdown_type == "F") {
        var code = `mlx90614_read("read_ambient_tempF")`;
    }
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['mlx90614_read_object'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.MLX90614_READ_OBJECT);
        this.appendDummyInput()
            .appendField(Blockly.Msg.MLX90614_READ_SET_TEMP)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.MLX90614_READ_SET_TEMP_C, "C"],
                [Blockly.Msg.MLX90614_READ_SET_TEMP_F, "F"]
            ]), "type");
        this.setInputsInline(false);
        this.setOutput(true, null);
        this.setColour("#5c42bd");
        this.setTooltip(Blockly.Msg.MLX90614_READ_OBJECT_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['mlx90614_read_object'] = function (block) {
    var dropdown_type = block.getFieldValue('type');
    if (dropdown_type == "C") {
        var code = `mlx90614_read("read_object_tempC")`;
    } else if (dropdown_type == "F") {
        var code = `mlx90614_read("read_object_tempF")`;
    }
    return [code, Blockly.Python.ORDER_NONE];
};

/* DHT11 or DHT22 */
Blockly.Blocks['DHT_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/dht_header.png", 60, 60, { alt: "*", flipRtl: "FALSE" }));
        let types = getLocalStorage("type")
        types == 1 ? this.appendDummyInput()
            .appendField("")
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.time_ai_module, "2"],
                [Blockly.Msg.time_iot_module, "1"]
            ]), "digital_get_type")
            .appendField(Blockly.Msg.DHT_SETUP_TEXT_1) :
            this.appendDummyInput()
                .appendField("")
                .appendField(new Blockly.FieldDropdown([
                    [Blockly.Msg.time_iot_module, "1"],
                    [Blockly.Msg.time_ai_module, "2"]
                ]), "digital_get_type")
                .appendField(Blockly.Msg.DHT_SETUP_TEXT_1);
        this.appendDummyInput()
            .appendField(Blockly.Msg.DHT_SETUP_TEXT_2)
            .appendField(new Blockly.FieldDropdown([
                ["DHT11", "1"],
                ["DHT22", "2"]
            ]), "type")
            .appendField(Blockly.Msg.DHT_SETUP_TEXT_3);
        types == 1 ? this.appendDummyInput()
            .appendField(Blockly.Msg.DHT_SETUP_TEXT_4)
            .appendField(new Blockly.FieldDropdown([
                ["1", "0"],
                ["2", "1"],
                ["3", "2"],
                ["13", "3"],
                ["14", "4"],
                ["15", "5"],
                ["17", "6"],
                ["21", "7"],
                ["22", "8"],
                ["23", "9"],
                ["24", "10"],
                ["29", "11"],
                ["30", "12"]
            ]), "gpio") :
            this.appendDummyInput()
                .appendField(Blockly.Msg.DHT_SETUP_TEXT_4)
                .appendField(new Blockly.FieldDropdown([
                    ["4", "0"],
                    ["12", "1"],
                    ["13", "2"],
                    ["14", "3"],
                    ["15", "4"],
                    ["16", "5"],
                    ["17", "6"],
                    ["21", "7"],
                    ["22", "8"],
                    ["25", "9"],
                    ["27", "10"]
                ]), "gpio");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setInputsInline(false);
        this.setColour("#629978");
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('digital_get_type');
            var TOOLTIPS = {
                '2': Blockly.Msg.DHT_SETUP_TOOLTIP.replace('%1', Blockly.Msg.time_ai_module),
                '1': Blockly.Msg.DHT_SETUP_TOOLTIP.replace('%1', Blockly.Msg.time_iot_module)
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['DHT_setup'] = function (block) {
    var dropdown_type = block.getFieldValue('digital_get_type');
    var type = block.getFieldValue('type');
    var gpio = block.getFieldValue('gpio');
    var code = '';
    if (dropdown_type == "1") {
        if (type == "1") {
            Blockly.Python.definitions_['import_iot_DHT_setup'] = '' +
                'import dht\n' +
                'import machine\n' +
                'import time\n' +
                '\n' +
                'd = dht.DHT11(machine.Pin(' + iot_servo_pin[gpio] + '))\n' +
                '\n';
            Blockly.Python.definitions_['import_DHT_read_data'] = '' +
                'def GetDHTTemperatureValue():\n' +
                '    try:\n' +
                '        d.measure()\n' +
                '        return d.temperature()\n' +
                '    except:\n' +
                '        return d.temperature()\n' +
                '\n' +
                'def GetDHTHumidityValue():\n' +
                '    try:\n' +
                '        d.measure()\n' +
                '        return d.humidity()\n' +
                '    except:\n' +
                '        return d.humidity()\n' +
                '\n' +
                '';
        }
        else {
            Blockly.Python.definitions_['import_iot_DHT_setup'] = '' +
                'import dht\n' +
                'import machine\n' +
                'import time\n' +
                '\n' +
                'd = dht.DHT22(machine.Pin(' + iot_servo_pin[gpio] + '))\n' +
                '\n';
            Blockly.Python.definitions_['import_DHT_read_data'] = '' +
                'def GetDHTTemperatureValue():\n' +
                '    try:\n' +
                '        d.measure()\n' +
                '        return d.temperature()\n' +
                '    except:\n' +
                '        return d.temperature()\n' +
                '\n' +
                'def GetDHTHumidityValue():\n' +
                '    try:\n' +
                '        d.measure()\n' +
                '        return d.humidity()\n' +
                '    except:\n' +
                '        return d.humidity()\n' +
                '\n' +
                '';
        }
    } else if (dropdown_type == "2") {
        if (type == "1") {
            Blockly.Python.definitions_['import_ai_DHT_setup'] = '' +
                'import dhtsensor\n' +
                'import time\n' +
                '\n' +
                'dhtsensor.DHT_IO_Register(' + ai_servo_pin[gpio] + ')\n' +
                'time.sleep_ms(100)\n' +
                '\n' +
                'temperature = None\n' +
                'humidity = None\n' +
                '\n';
            Blockly.Python.definitions_['import_DHT_read_data'] = '' +
                'def GetDHTTemperatureValue():\n' +
                '    global temperature,humidity\n' +
                '    if dhtsensor.measure() and temperature == None:\n' +
                '        temperature = dhtsensor.GetDHT11_temperature()\n' +
                '        humidity = dhtsensor.GetDHT11_humidity()\n' +
                '        time.sleep_ms(1000)\n' +
                '        return temperature\n' +
                '    elif temperature != None:\n' +
                '        temperature = dhtsensor.GetDHT11_temperature()\n' +
                '        humidity = None\n' +
                '        return temperature\n' +
                '\n' +
                'def GetDHTHumidityValue():\n' +
                '    global temperature,humidity\n' +
                '    if dhtsensor.measure() and humidity == None:\n' +
                '        temperature = dhtsensor.GetDHT11_temperature()\n' +
                '        humidity = dhtsensor.GetDHT11_humidity()\n' +
                '        time.sleep_ms(1000)\n' +
                '        return humidity\n' +
                '    elif humidity != None:\n' +
                '        humidity = dhtsensor.GetDHT11_humidity()\n' +
                '        temperature = None\n' +
                '        return humidity\n' +
                '\n' +
                '';
        }
        else {
            Blockly.Python.definitions_['import_ai_DHT_setup'] = '' +
                'import dhtsensor\n' +
                'import time\n' +
                '\n' +
                'dhtsensor.DHT_IO_Register(' + ai_servo_pin[gpio] + ')\n' +
                'time.sleep_ms(100)\n' +
                '\n' +
                'temperature = None\n' +
                'humidity = None\n' +
                '\n';
            Blockly.Python.definitions_['import_DHT_read_data'] = '' +
                'def GetDHTTemperatureValue():\n' +
                '    global temperature,humidity\n' +
                '    if dhtsensor.measure() and temperature == None:\n' +
                '        temperature = dhtsensor.GetDHT22_temperature()\n' +
                '        humidity = dhtsensor.GetDHT22_humidity()\n' +
                '        time.sleep_ms(1000)\n' +
                '        return temperature * 0.1\n' +
                '    elif temperature != None:\n' +
                '        temperature = dhtsensor.GetDHT22_temperature()\n' +
                '        humidity = None\n' +
                '        return temperature * 0.1\n' +
                '\n' +
                'def GetDHTHumidityValue():\n' +
                '    global temperature,humidity\n' +
                '    if dhtsensor.measure() and humidity == None:\n' +
                '        temperature = dhtsensor.GetDHT22_temperature()\n' +
                '        humidity = dhtsensor.GetDHT22_humidity()\n' +
                '        time.sleep_ms(1000)\n' +
                '        return humidity * 0.1\n' +
                '    elif humidity != None:\n' +
                '        humidity = dhtsensor.GetDHT22_humidity()\n' +
                '        temperature = None\n' +
                '        return humidity * 0.1\n' +
                '\n' +
                '';
        }
    }
    return code;
};

Blockly.Blocks['DHT_read_data'] = {
    init: function () {
        // this.appendDummyInput()
        //    .appendField(new Blockly.FieldImage("blockly/media/env_get.png", 38, 38, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.ESP32_ENV_GET_TEXT)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.basic_temperature, "temperature"],
                [Blockly.Msg.basic_humidity, "humidity"]
                // [Blockly.Msg.basic_pressure, "pressure"]
            ]), "env_get_type")
            .appendField(Blockly.Msg.basic_env_value);
        this.setInputsInline(false);
        this.setOutput(true, null);
        this.setColour("#629978");
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('env_get_type');
            var TOOLTIPS = {
                'temperature': Blockly.Msg.Esp32_Main_Controller_Get_Environmental_Value_TOOLTIP.replace('%1', Blockly.Msg.basic_temperature),
                'humidity': Blockly.Msg.Esp32_Main_Controller_Get_Environmental_Value_TOOLTIP.replace('%1', Blockly.Msg.basic_humidity)
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['DHT_read_data'] = function (block) {
    var env_get_type = block.getFieldValue('env_get_type');
    var code = "";
    if (env_get_type == "temperature") {
        code = 'GetDHTTemperatureValue()';
    } else if (env_get_type == "humidity") {
        code = 'GetDHTHumidityValue()';
    }
    return [code, Blockly.Python.ORDER_NONE];
};

/* PM2.5 */
Blockly.Blocks['PM25_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/pm25sensor_setup.png", 220, 60, { alt: "*", flipRtl: "FALSE" }));
        let types = getLocalStorage("type")
        types == 1 ? this.appendDummyInput()
            .appendField("")
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.time_ai_module, "2"],
                [Blockly.Msg.time_iot_module, "1"]
            ]), "digital_get_type")
            .appendField(Blockly.Msg.PM25_SETUP_TEXT) :
            this.appendDummyInput()
                .appendField("")
                .appendField(new Blockly.FieldDropdown([
                    [Blockly.Msg.time_iot_module, "1"],
                    [Blockly.Msg.time_ai_module, "2"]
                ]), "digital_get_type")
                .appendField(Blockly.Msg.PM25_SETUP_TEXT);
        this.appendDummyInput()
            .appendField(Blockly.Msg.DHT_SETUP_TEXT_2)
            .appendField(new Blockly.FieldDropdown([
                ["GP2Y10", "1"]
            ]), "type")
            .appendField(Blockly.Msg.DHT_SETUP_TEXT_3);
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setInputsInline(false);
        this.setColour("#386dc8");
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('digital_get_type');
            var TOOLTIPS = {
                '2': Blockly.Msg.PM25_SETUP_TOOLTIP.replace('%1', Blockly.Msg.time_ai_module),
                '1': Blockly.Msg.PM25_SETUP_TOOLTIP.replace('%1', Blockly.Msg.time_iot_module)
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['PM25_setup'] = function (block) {
    var dropdown_type = block.getFieldValue('digital_get_type');
    var type = block.getFieldValue('type');
    var code = '';
    if (dropdown_type == "1") {
        if (type == "1") {
            Blockly.Python.definitions_['import_iot_PM25_setup'] = '' +
                'from machine import UART, Pin\n' +
                'import pm25\n' +
                '\n' +
                'uart = UART(2, baudrate=2400, rx=16, tx=17, timeout=10)\n' +
                '\n';
        }
    } else if (dropdown_type == "2") {
        if (type == "1") {
            Blockly.Python.definitions_['import_ai_PM25_setup'] = '' +
                'import machine, time\n' +
                'from fpioa_manager import fm\n' +
                'import pm25\n' +
                '\n' +
                'fm.register(13,fm.fpioa.UART2_TX)\n' +
                'fm.register(14,fm.fpioa.UART2_RX)\n' +
                '\n' +
                'uart = machine.UART(machine.UART.UART2,2400,bits=8,parity=None,stop=1)\n' +
                '\n';
        }
    }
    return code;
};

Blockly.Blocks['PM25_read_data'] = {
    init: function () {
        // this.appendDummyInput()
        //    .appendField(new Blockly.FieldImage("blockly/media/env_get.png", 38, 38, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField(Blockly.Msg.ESP32_ENV_GET_TEXT)
            .appendField("PM 2.5")
            .appendField(Blockly.Msg.basic_env_value);
        this.setInputsInline(false);
        this.setOutput(true, null);
        this.setTooltip(Blockly.Msg.PM25_REDD_DATA_TOOLTIP);
        this.setColour("#386dc8");
        this.setHelpUrl("");
    }
};

Blockly.Python['PM25_read_data'] = function (block) {
    var code = "pm25.getPM25Value(uart)";
    return [code, Blockly.Python.ORDER_NONE];
};

/* RTC */
var rtcColor = "#3c7683";

Blockly.Blocks['RTC_setup'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(new Blockly.FieldImage("blockly/media/sensors-rtc.png", 60, 60, { alt: "*", flipRtl: "FALSE" }));
        this.appendDummyInput()
            .appendField("")
            .appendField(Blockly.Msg.time_ai_module)
            .appendField(Blockly.Msg.RTC_SETUP);
        this.appendDummyInput()
            .appendField(Blockly.Msg.DHT_SETUP_TEXT_2)
            .appendField(new Blockly.FieldDropdown([
                ["DS3231", "1"]
            ]), "type");
        this.setPreviousStatement(true, null);
        this.setNextStatement(true, null);
        this.setInputsInline(false);
        this.setColour(rtcColor);
        this.setHelpUrl("");
        this.setTooltip(Blockly.Msg.RTC_setup_TOOLTIP);
    }
};

Blockly.Python['RTC_setup'] = function (block) {
    var type = block.getFieldValue('type');
    var code = '';
    if (type == "1") {
        Blockly.Python.definitions_['import_iot_RTC_setup'] = '' +
            'import machine\n' +
            'import DS3231micro\n' +
            '\n' +
            'rtc = DS3231micro.DS3231(30, 29)\n' +
            '\n';
    }
    return code;
};


Blockly.Blocks['RTC_setDateTime'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_SETDATETIME);
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_SETDATE)
            .appendField(new Blockly.FieldNumber(18, 0, 50), "year")
            .appendField("-")
            .appendField(new Blockly.FieldNumber(1, 0, 12), "month")
            .appendField("-")
            .appendField(new Blockly.FieldNumber(1, 0, 31), "day")
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_SETTIME)
            .appendField(new Blockly.FieldNumber(12, 0, 24), "hour")
            .appendField(":")
            .appendField(new Blockly.FieldNumber(30, 0, 60), "minute")
            .appendField(":")
            .appendField(new Blockly.FieldNumber(10, 0, 60), "second")
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_SETWEEK)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.Monday, "1"],
                [Blockly.Msg.Tuesday, "2"],
                [Blockly.Msg.Wednesday, "3"],
                [Blockly.Msg.Thursday, "4"],
                [Blockly.Msg.Friday, "5"],
                [Blockly.Msg.Saturday, "6"],
                [Blockly.Msg.Sunday, "7"]
            ]), "week")
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setColour(rtcColor);
        this.setTooltip(Blockly.Msg.RTC_setDateTime_TOOLTIP);
        this.setHelpUrl("");
    },
    /**
     * Called whenever anything on the workspace changes.
     * It checks the number of data and time settting 
     * @this Blockly.Block
     */
    onchange: function () {
        if (this.getFieldValue("year") > 50) {
            this.setFieldValue("19", "year");
        }
        if (this.getFieldValue("month") > 12) {
            this.setFieldValue("12", "month");
        } else if (this.getFieldValue("month") < 0) {
            this.setFieldValue("1", "month");
        }
        if (this.getFieldValue("day") > 31) {
            this.setFieldValue("31", "day");
        } else if (this.getFieldValue("day") < 0) {
            this.setFieldValue("1", "day");
        }
        if (this.getFieldValue("hour") > 24) {
            this.setFieldValue("24", "hour");
        } else if (this.getFieldValue("hour") < 0) {
            this.setFieldValue("1", "hour");
        }
        if (this.getFieldValue("minute") > 60) {
            this.setFieldValue("60", "minute");
        } else if (this.getFieldValue("minute") < 0) {
            this.setFieldValue("1", "minute");
        }
        if (this.getFieldValue("second") > 60) {
            this.setFieldValue("60", "second");
        } else if (this.getFieldValue("second") < 0) {
            this.setFieldValue("1", "second");
        }
    }
};

Blockly.Python['RTC_setDateTime'] = function (block) {
    var year = block.getFieldValue("year");
    var month = block.getFieldValue("month");
    var day = block.getFieldValue("day");
    var hour = block.getFieldValue("hour");
    var minute = block.getFieldValue("minute");
    var second = block.getFieldValue("second");
    var week = block.getFieldValue('week');
    var code = 'rtc.setDateTime(' + year + ',' + month + ',' + day + ',' + week + ',' + hour + ',' + minute + ',' + second + ')\n';
    return code;
};

Blockly.Blocks['RTC_getDate'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_GETDATE)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.RTC_YEAR, "year"],
                [Blockly.Msg.RTC_MONTH, "month"],
                [Blockly.Msg.RTC_DAY, "day"],
            ]), "date_detail")
        this.setColour(rtcColor);
        this.setOutput(true, null);
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('date_detail');
            var TOOLTIPS = {
                "year": Blockly.Msg.RTC_GETDATE_TOOLTIP.replace('%1', Blockly.Msg.RTC_YEAR),
                "month": Blockly.Msg.RTC_GETDATE_TOOLTIP.replace('%1', Blockly.Msg.RTC_MONTH),
                "day": Blockly.Msg.RTC_GETDATE_TOOLTIP.replace('%1', Blockly.Msg.RTC_DAY),
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['RTC_getDate'] = function (block) {
    var date_detail = block.getFieldValue("date_detail");
    var code = '';
    if (date_detail == "year") {
        code = 'rtc.getYear()';
    }
    else if (date_detail == "month") {
        code = 'rtc.getMonth()';
    }
    else {
        code = 'rtc.getDay()';
    }
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['RTC_getTime'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_GETTIME)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.RTC_HOUR, "hour"],
                [Blockly.Msg.RTC_MINUTE, "minute"],
                [Blockly.Msg.RTC_SECOND, "second"],
            ]), "time_detail")
        this.setColour(rtcColor);
        this.setOutput(true, null);
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('time_detail');
            var TOOLTIPS = {
                "hour": Blockly.Msg.RTC_GETTIME_TOOLTIP.replace('%1', Blockly.Msg.RTC_HOUR),
                "minute": Blockly.Msg.RTC_GETTIME_TOOLTIP.replace('%1', Blockly.Msg.RTC_MINUTE),
                "second": Blockly.Msg.RTC_GETTIME_TOOLTIP.replace('%1', Blockly.Msg.RTC_SECOND),
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['RTC_getTime'] = function (block) {
    var time_detail = block.getFieldValue("time_detail");
    var code = '';
    if (time_detail == "hour") {
        code = 'rtc.getHour()';
    }
    else if (time_detail == "minute") {
        code = 'rtc.getMinutes()';
    }
    else {
        code = 'rtc.getSeconds()';
    }
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['RTC_getWeek'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_GETWEEK);
        this.setColour(rtcColor);
        this.setOutput(true, null);
        this.setTooltip(Blockly.Msg.RTC_getWeek_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['RTC_getWeek'] = function (block) {
    var code = 'rtc.getDayOfWeek()';
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['RTC_getDateTime'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_getDateTime);
        this.setColour(rtcColor);
        this.setOutput(true, null);
        this.setTooltip(Blockly.Msg.RTC_getDateTime_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['RTC_getDateTime'] = function (block) {
    var code = 'rtc.getDateTime()';
    return [code, Blockly.Python.ORDER_NONE];
};

Blockly.Blocks['RTC_setDate'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_setDATE)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.RTC_YEAR, "year"],
                [Blockly.Msg.RTC_MONTH, "month"],
                [Blockly.Msg.RTC_DAY, "day"],
            ]), "date_detail")
            .appendField(Blockly.Msg.RTC_WEI)
            .appendField(new Blockly.FieldNumber(0, null, null), "date")
        this.setOutput(false, null);
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setColour(rtcColor);
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('date_detail');
            var TOOLTIPS = {
                "year": Blockly.Msg.RTC_SETDATE_TOOLTIP.replace('%1', Blockly.Msg.RTC_YEAR),
                "month": Blockly.Msg.RTC_SETDATE_TOOLTIP.replace('%1', Blockly.Msg.RTC_MONTH),
                "day": Blockly.Msg.RTC_SETDATE_TOOLTIP.replace('%1', Blockly.Msg.RTC_DAY),
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['RTC_setDate'] = function (block) {
    var date_detail = block.getFieldValue("date_detail");
    var date = block.getFieldValue("date");
    var code = '';
    if (date_detail == "year") {
        code = 'rtc.setYear(' + date + ')\n';
    }
    else if (date_detail == "month") {
        code = 'rtc.setMonth(' + date + ')\n';
    }
    else {
        code = 'rtc.setDay(' + date + ')\n';
    }
    return code;
};

Blockly.Blocks['RTC_setTime'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_setTIME)
            .appendField(new Blockly.FieldDropdown([
                [Blockly.Msg.RTC_HOUR, "hour"],
                [Blockly.Msg.RTC_MINUTE, "minute"],
                [Blockly.Msg.RTC_SECOND, "second"],
            ]), "time_detail")
            .appendField(Blockly.Msg.RTC_WEI)
            .appendField(new Blockly.FieldNumber(0, 0, null), "time")
        this.setColour(rtcColor);
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setHelpUrl("");
        var thisBlock = this;
        this.setTooltip(function () {
            var mode = thisBlock.getFieldValue('time_detail');
            var TOOLTIPS = {
                "hour": Blockly.Msg.RTC_SETTIME_TOOLTIP.replace('%1', Blockly.Msg.RTC_HOUR),
                "minute": Blockly.Msg.RTC_SETTIME_TOOLTIP.replace('%1', Blockly.Msg.RTC_MINUTE),
                "second": Blockly.Msg.RTC_SETTIME_TOOLTIP.replace('%1', Blockly.Msg.RTC_SECOND),
            };
            return TOOLTIPS[mode];
        });
    }
};

Blockly.Python['RTC_setTime'] = function (block) {
    var time_detail = block.getFieldValue("time_detail");
    var time = block.getFieldValue("time");
    var code = '';
    if (time_detail == "hour") {
        code = 'rtc.setHour(' + time + ')\n';
    }
    else if (time_detail == "minute") {
        code = 'rtc.setMinutes(' + time + ')\n';
    }
    else {
        code = 'rtc.setSeconds(' + time + ')\n';
    }
    return code;
};

Blockly.Blocks['RTC_setWeek'] = {
    init: function () {
        this.appendDummyInput()
            .appendField(Blockly.Msg.RTC_setWEEK)
            .appendField(new Blockly.FieldNumber(1, 0, null), "week");
        this.setColour(rtcColor);
        this.setPreviousStatement(true);
        this.setNextStatement(true);
        this.setTooltip(Blockly.Msg.RTC_setWeek_TOOLTIP);
        this.setHelpUrl("");
    }
};

Blockly.Python['RTC_setWeek'] = function (block) {
    var week = block.getFieldValue("week");
    var code = 'rtc.setDayOfWeek(' + week + ')\n';
    return code;
};