3930 lines
215 KiB
JavaScript
3930 lines
215 KiB
JavaScript
(() => {
|
||
|
||
'use strict';
|
||
goog.require('Blockly.Lang');
|
||
goog.provide('Blockly.Lang.En');
|
||
|
||
const { En } = Blockly.Lang;
|
||
|
||
En.MSG = {
|
||
catInOut: "In/Out",
|
||
catControl: "Control",
|
||
catMath: "Math",
|
||
catText: "Text",
|
||
catLists: "Lists",
|
||
catMicropyLists: "Lists",
|
||
catDicts: "Dictory",
|
||
catLogic: "Logic",
|
||
catSerialPort: "SerialPort",
|
||
catGroup: "Communicate",
|
||
catIR: "IR Communicate",
|
||
catESPNow: "ESPNow Communicate",
|
||
catLora: "Lora Communicate",
|
||
catI2C: "I2C",
|
||
catSPI: "SPI",
|
||
catSocket: "Wireless socket",
|
||
catRFID: "RFID",
|
||
catStorage: "Storage",
|
||
catStorageSD: 'SD',
|
||
catStorageSPIFFS: 'SPIFFS',
|
||
catStorageEEPROM: 'EEPROM',
|
||
catME_GO:"ME GO",
|
||
catME_G1:"ME G1",
|
||
catPE_G1:"PE G1",
|
||
catCE_G6:"CE G6",
|
||
catCC_G1:"CC G1",
|
||
catMINI_G2:"MINI G2",
|
||
catMINI_G5:"MINI G5",
|
||
catSANT_G2:"SANT G2",
|
||
catNova_G1:"Nova G1",
|
||
catAIOT:"Intelligent IOT",
|
||
catAIsensor:"MixGoAI Sensor",
|
||
catAIsensor2:"MixGoAI image identification",
|
||
catSensor: "Sensor",
|
||
catActuator: "Actuator",
|
||
catExternSensor: "External Sensor",
|
||
catExternAI: "Machine vision",
|
||
catExternActuator: "External Actuator",
|
||
catExternMonitor: "External Monitor",
|
||
catActuator_motor: "Motor",
|
||
catActuator_voice: "Sound",
|
||
catActuator_light: "Light",
|
||
catMonitor: "Monitor",
|
||
catVar: "Variables",
|
||
catFun: "Functions",
|
||
catNetwork: "Network",
|
||
catEthernet: "Ethernet",
|
||
catEthernet_init: "Init",
|
||
catEthernet_clinet: "Client",
|
||
tab_blocks: "Blocks",
|
||
tab_arduino: "Code",
|
||
copyright: "Copyright © Mixly Team@BNU, CHINA",
|
||
catGame: "Game",
|
||
catSystem: "System",
|
||
catTurtle: "Turtle",
|
||
catTuple: "Tuple",
|
||
catIot: "IOT",
|
||
catSet: "Set",
|
||
catData: "Data",
|
||
catAlgorithm: "Algorithm",
|
||
catHardware: "Hardware",
|
||
catAI: "AI",
|
||
catHear: "machine Hear",
|
||
catImage: "machine vision",
|
||
catTFT: "TFT Screen",
|
||
catAV: "Audio/Video",
|
||
catCamera: "Camera ",
|
||
catImage_Draw: "Image rendering ",
|
||
catImage_Base: "Image foundation",
|
||
catImage_Filte: "Image filtering",
|
||
catImage_Shpe: "Shape recognition",
|
||
catImage_Color: "Color recognition",
|
||
catImage_Codes: "Code recognition ",
|
||
catImage_Features: "Feature recognition",
|
||
catShaw: 'MixNo/MixPY',
|
||
catDS: "Data Structure",
|
||
catOnBoard: 'Board',
|
||
catOnBoardDisplay: 'Board Display',
|
||
catOnBoardOled: 'Board Display',
|
||
catOnBoardSensor: 'Board Sensor',
|
||
catOnBoardActuator: 'Board Actuator',
|
||
cat4Digitdisplay: '4Digitdisplay',
|
||
catLCD: 'LCD',
|
||
catOLED: 'OLED Screen',
|
||
catMatrix: 'Matrix',
|
||
catFactory: 'Factory',
|
||
catBlynk: 'Blynk IoT',
|
||
catFile: 'File',
|
||
catOnenet: 'OneNET',
|
||
catTools: 'Tools',
|
||
catWIFI: 'Wi-Fi',
|
||
catMQTT: 'MQTT',
|
||
catsklearn: 'Machine learning',
|
||
catclass_make: "Classes and objects",
|
||
catclass: "Class",
|
||
catproperty: "Attributes",
|
||
catmethod: "Method",
|
||
catobject: "Object",
|
||
catEvents: "Events",
|
||
catExtend: "Extend",
|
||
catMixIO: "MixIO",
|
||
catCommunicate: "requests",
|
||
catBlynk: "Blynk IoT",
|
||
undo: "Undo",
|
||
redo: "Redo",
|
||
file: "File",
|
||
new: "New",
|
||
open: "Open",
|
||
save: "Save",
|
||
save_blocks: "Save MIX",
|
||
save_py: "Save PY",
|
||
save_ino: "Save INO",
|
||
save_img: "Save PNG",
|
||
save_hex: "Save HEX",
|
||
setting: "Setting",
|
||
language: "Language",
|
||
theme: "Theme",
|
||
connect: "Connect",
|
||
upload: "Upload",
|
||
step_run: "Single step",
|
||
run: "Run",
|
||
stop: "Stop",
|
||
fn: "Filename",
|
||
choose_theme: "Please choose your theme:",
|
||
choose_language: "Please choose your language:",
|
||
confirm_newfile: "Do you want to clear all the contents?",
|
||
newfile_yes: "Yes",
|
||
newfile_no: "Cancel",
|
||
burn: "Initialize",
|
||
upload_to_board: "Upload",
|
||
statusbar: "Status Bar",
|
||
operate: "Operate",
|
||
compile: "Compile",
|
||
import_libraries: "Import",
|
||
export_libraries: "Export",
|
||
manage_libraries: "Manager",
|
||
change_board: "Switch",
|
||
save_as: "Save as",
|
||
simulate: "Simulate",
|
||
disconnect: "Disconnect",
|
||
catweather: "Seniverse weather",
|
||
view_btn: "Cloud File",
|
||
view_file: "Resources",
|
||
open_from_cloud: "Open from the cloud",
|
||
save_ser: "Save to the cloud",
|
||
windowSize: "Window size",
|
||
catRadio: "Radio",
|
||
catMusic: "Music",
|
||
catAudio: "Audio",
|
||
catNeopixel: "RGB light",
|
||
catOneWire: "OneWire Communicate",
|
||
catBLE: "Bluetooth transmission",
|
||
catBLEC:"Bluetooth remote control",
|
||
catBLEKM:"Bluetooth keyboard and mouse",
|
||
catBLE_HID: "Peripheral Device (Slave)",
|
||
catBLE_UART: "Central Device (Host)",
|
||
catBLE_PERIPHERAL: "Serial port transparent transmission",
|
||
catBLE_CENTERAL: "Human Computer Interaction",
|
||
catBLE_IBEACON: "iBeacon device",
|
||
other_firmware: "Firmware",
|
||
catWebData: "Data from Web",
|
||
feedback: "Feedback",
|
||
disablePythonToBlockly: "Blocks↔Code",
|
||
enablePythonToBlockly: "Blocks↔Code",
|
||
catSearch: "Search",
|
||
wiki: "Wiki"
|
||
};
|
||
|
||
/* 多重选择 */
|
||
En.CROSS_TAB_COPY = 'Cross tab Copy';
|
||
// En.CROSS_TAB_COPY_X_BLOCKS = 'Cross tab copy %1 Blocks';
|
||
En.CROSS_TAB_PASTE = 'Cross tab Paste';
|
||
En.SELECT_ALL = 'Select all Blocks';
|
||
|
||
/* 下载模块图像 */
|
||
En.DOWNLOAD_SCREENSHOT = 'Download Screenshot';
|
||
|
||
/* 小地图 */
|
||
En.MINIMAP_OPEN = 'Expand Mini Map';
|
||
En.MINIMAP_CLOSE = 'Collapse Mini Map';
|
||
|
||
/* 背包 */
|
||
En.COPY_ALL_TO_BACKPACK = 'Copy All Blocks to Backpack';
|
||
En.COPY_TO_BACKPACK = 'Copy to Backpack';
|
||
En.EMPTY_BACKPACK = 'Empty';
|
||
En.PASTE_ALL_FROM_BACKPACK = 'Paste All Blocks from Backpack';
|
||
En.REMOVE_FROM_BACKPACK = 'Remove from Backpack';
|
||
|
||
/* 工作区块查找 */
|
||
En.WORKSPACE_SEARCH_OPEN = 'Search blocks';
|
||
En.SEARCH = 'Search';
|
||
|
||
/* Blockly.FieldBitmap文本翻译 */
|
||
En.RANDOM = 'Random';
|
||
En.CLEAR = 'Clear';
|
||
|
||
/* Blockly.FieldColourHsvSliders文本翻译 */
|
||
En.HUE = 'Hue';
|
||
En.SATURATION = 'Saturation';
|
||
En.BRIGHTNESS = 'Brightness';
|
||
En.EYEDROPPER = 'Eyedropper';
|
||
|
||
/* Blockly.FieldDate文本翻译 */
|
||
En.TODAY = 'Today';
|
||
|
||
En.WORKSPACE_COMMENT_DEFAULT_TEXT = "Say something...";
|
||
En.REMOVE_COMMENT = "Remove Comment";
|
||
En.DUPLICATE_COMMENT = "Duplicate Comment";
|
||
En.ADD_COMMENT = "Add Comment";
|
||
En.AUTH = "Please authorize this app to enable your work to be saved and to allow it to be shared by you.";
|
||
En.CHANGE_VALUE_TITLE = "Change value:";
|
||
En.CHAT = "Chat with your collaborator by typing in this box!";
|
||
En.CLEAN_UP = "Clean up Blocks";
|
||
En.COLLAPSE_ALL = "Collapse Blocks";
|
||
En.COLLAPSE_BLOCK = "Collapse Block";
|
||
// En.COLLAPSE_X_BLOCKS = "Collapse %1 Blocks";
|
||
En.DELETE_ALL_BLOCKS = 'Delete all %1 blocks?';
|
||
En.DELETE_BLOCK = "Delete Block";
|
||
// En.DELETE_X_BLOCKS = "Delete %1 Blocks";
|
||
En.DISABLE_BLOCK = "Disable Block";
|
||
// En.DISABLE_X_BLOCKS = "Disable %1 Blocks";
|
||
En.DUPLICATE_BLOCK = "Duplicate";
|
||
// En.DUPLICATE_X_BLOCKS = "Duplicate %1 Blocks";
|
||
En.ENABLE_BLOCK = "Enable Block";
|
||
// En.ENABLE_X_BLOCKS = "Enable %1 Blocks";
|
||
En.EXPAND_ALL = "Expand Blocks";
|
||
En.EXPAND_BLOCK = "Expand Block";
|
||
// En.EXPAND_X_BLOCKS = "Expand %1 Blocks";
|
||
En.COLOUR_BLEND_COLOUR1 = "colour 1";
|
||
En.COLOUR_BLEND_COLOUR2 = "colour 2";
|
||
En.COLOUR_BLEND_HELPURL = "http://meyerweb.com/eric/tools/color-blend/";
|
||
En.COLOUR_BLEND_RATIO = "ratio";
|
||
En.COLOUR_BLEND_TITLE = "blend";
|
||
En.COLOUR_BLEND_TOOLTIP = "Blends two colours together with a given ratio (0.0 - 1.0).";
|
||
En.COLOUR_PICKER_HELPURL = "https://en.wikipedia.org/wiki/Color";
|
||
En.COLOUR_PICKER_TOOLTIP = "Choose a colour from the palette.";
|
||
En.COLOUR_RANDOM_HELPURL = "http://randomcolour.com";
|
||
En.COLOUR_RANDOM_TITLE = "random colour";
|
||
En.COLOUR_RANDOM_TOOLTIP = "Choose a colour at random.";
|
||
En.COLOUR_RGB_BLUE = "blue";
|
||
En.COLOUR_RGB_GREEN = "green";
|
||
En.COLOUR_RGB_HELPURL = "http://www.december.com/html/spec/colorper.html";
|
||
En.COLOUR_RGB_RED = "red";
|
||
En.COLOUR_RGB_TOOLTIP = "Create a colour with the specified amount of red, green, and blue. All values must be between 0 and 100.";
|
||
En.CONTROLS_FLOW_STATEMENTS_HELPURL = "https://github.com/google/blockly/wiki/Loops#loop-termination-blocks";
|
||
En.CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK = "break out of loop";
|
||
En.CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE = "continue with next iteration of loop";
|
||
En.CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK = "Break out of the containing loop.";
|
||
En.CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE = "Skip the rest of this loop, and continue with the next iteration.";
|
||
En.CONTROLS_FLOW_STATEMENTS_WARNING = "Warning: This block may only be used within a loop.";
|
||
En.CONTROLS_FOREACH_HELPURL = "https://github.com/google/blockly/wiki/Loops#for-each for each block";
|
||
En.CONTROLS_FOREACH_INPUT_INLIST_TAIL = "";
|
||
En.CONTROLS_FOREACH_INPUT_INLIST_TAIL = "";
|
||
En.CONTROLS_FOREACH_INPUT_ITEM = "for each item";
|
||
En.CONTROLS_FOREACH_TOOLTIP = "For each item in a list, set the variable '%1' to the item, and then do some statements.";
|
||
En.CONTROLS_FOR_HELPURL = "https://github.com/google/blockly/wiki/Loops#count-with";
|
||
En.CONTROLS_FOR_INPUT_FROM_TO = "from %1 to %2";
|
||
En.CONTROLS_FOR_INPUT_FROM_TO_BY = "from %1 to %2 by %3";
|
||
En.CONTROLS_FOR_INPUT_WITH = "count with";
|
||
En.CONTROLS_FOR_TOOLTIP = "Have the variable %1 take on the values from the start number to the end number, counting by the specified interval, and do the specified blocks.";
|
||
En.CONTROLS_IF_ELSEIF_TOOLTIP = "Add a condition to the if block.";
|
||
En.CONTROLS_IF_ELSE_TOOLTIP = "Add a final, catch-all condition to the if block.";
|
||
En.CONTROLS_IF_HELPURL = "https://github.com/google/blockly/wiki/IfElse";
|
||
En.CONTROLS_IF_IF_TOOLTIP = "Add, remove, or reorder sections to reconfigure this if block.";
|
||
En.CONTROLS_IF_MSG_ELSE = "else";
|
||
En.CONTROLS_IF_MSG_ELSEIF = "else if";
|
||
En.CONTROLS_IF_MSG_IF = "if";
|
||
En.CONTROLS_IF_TOOLTIP_1 = "If a value is true, then do some statements.";
|
||
En.CONTROLS_IF_TOOLTIP_2 = "If a value is true, then do the first block of statements. Otherwise, do the second block of statements.";
|
||
En.CONTROLS_IF_TOOLTIP_3 = "If the first value is true, then do the first block of statements. Otherwise, if the second value is true, do the second block of statements.";
|
||
En.CONTROLS_IF_TOOLTIP_4 = "If the first value is true, then do the first block of statements. Otherwise, if the second value is true, do the second block of statements. If none of the values are true, do the last block of statements.";
|
||
En.CONTROLS_REPEAT_HELPURL = "https://en.wikipedia.org/wiki/For_loop";
|
||
En.CONTROLS_REPEAT_INPUT_DO = "do";
|
||
En.CONTROLS_REPEAT_TITLE = "repeat %1 times";
|
||
En.CONTROLS_REPEAT_TITLE_REPEAT = "repeat";
|
||
En.CONTROLS_REPEAT_TITLE_TIMES = "times";
|
||
En.CONTROLS_REPEAT_TITLE_REPEAT = "repeat";
|
||
En.CONTROLS_WHILEUNTIL_HELPURL = "https://github.com/google/blockly/wiki/Loops#repeat";
|
||
En.CONTROLS_WHILEUNTIL_OPERATOR_UNTIL = "repeat until";
|
||
En.CONTROLS_WHILEUNTIL_OPERATOR_WHILE = "repeat while";
|
||
En.CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL = "While a value is false, then do some statements.";
|
||
En.CONTROLS_WHILEUNTIL_TOOLTIP_WHILE = "While a value is true, then do some statements.";
|
||
En.EXTERNAL_INPUTS = "External Inputs";
|
||
En.HELP = "Help";
|
||
En.INLINE_INPUTS = "Inline Inputs";
|
||
En.LISTS_CREATE_EMPTY_HELPURL = "https://github.com/google/blockly/wiki/Lists#create-empty-list";
|
||
En.LISTS_CREATE_EMPTY_TITLE = "create empty list";
|
||
En.LISTS_CREATE_EMPTY_TOOLTIP = "Returns a list, of length 0, containing no data records";
|
||
En.LISTS_CREATE_WITH_CONTAINER_TITLE_ADD = "list";
|
||
En.LISTS_CREATE_WITH_CONTAINER_TOOLTIP = "Add, remove, or reorder sections to reconfigure this list block.";
|
||
En.LISTS_CREATE_WITH_HELPURL = "https://github.com/google/blockly/wiki/Lists#create-list-with";
|
||
En.LISTS_CREATE_WITH_INPUT_WITH = "create list with";
|
||
En.LISTS_CREATE_WITH_ITEM_TOOLTIP = "Add an item to the list.";
|
||
En.LISTS_CREATE_WITH_TOOLTIP = "Create a list with any number of items.";
|
||
En.LISTS_GET_INDEX_FIRST = "first";
|
||
En.LISTS_GET_INDEX_FROM_END = "# from end";
|
||
En.LISTS_GET_INDEX_FROM_START = "#";
|
||
En.LISTS_GET_INDEX_GET = "get";
|
||
En.LISTS_GET_INDEX_GET_REMOVE = "get and remove";
|
||
En.LISTS_GET_INDEX_LAST = "last";
|
||
En.LISTS_GET_INDEX_RANDOM = "random";
|
||
En.LISTS_GET_RANDOM_SUBLIST = "to make up a sublist";
|
||
En.LISTS_GET_INDEX_REMOVE = "remove";
|
||
En.LISTS_GET_INDEX_TAIL = "";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_FIRST = "Returns the first item in a list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_FROM_END = "Returns the item at the specified position in a list. #1 is the last item.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_FROM_START = "Returns the item at the specified position in a list. #1 is the first item.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_LAST = "Returns the last item in a list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST = "Removes and returns the first item in a list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM_END = "Removes and returns the item at the specified position in a list. #1 is the last item.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM_START = "Removes and returns the item at the specified position in a list. #1 is the first item.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST = "Removes and returns the last item in a list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST = "Removes the first item in a list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM_END = "Removes the item at the specified position in a list. #1 is the last item.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM_START = "Removes the item at the specified position in a list. #1 is the first item.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST = "Removes the last item in a list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM = "Removes a random item in a list.";
|
||
En.LISTS_GET_SUBLIST_END_FROM_END = "to # from end";
|
||
En.LISTS_GET_SUBLIST_END_FROM_START = "to #";
|
||
En.LISTS_GET_SUBLIST_END_LAST = "to last";
|
||
En.LISTS_GET_SUBLIST_HELPURL = "https://github.com/google/blockly/wiki/Lists#getting-a-sublist";
|
||
En.LISTS_GET_SUBLIST_START_FIRST = "get sub-list from first";
|
||
En.LISTS_GET_SUBLIST_START_FROM_END = "get sub-list from # from end";
|
||
En.LISTS_GET_SUBLIST_START_FROM_START = "get sub-list from #";
|
||
En.LISTS_GET_SUBLIST_TAIL = "";
|
||
En.LISTS_GET_SUBLIST_TOOLTIP = "Creates a copy of the specified portion of a list.";
|
||
En.LISTS_INDEX_OF_FIRST = "find first occurrence of item";
|
||
En.LISTS_INDEX_OF_HELPURL = "https://github.com/google/blockly/wiki/Lists#getting-items-from-a-list";
|
||
En.LISTS_INDEX_OF_LAST = "find last occurrence of item";
|
||
En.LISTS_INDEX_OF_TOOLTIP = "Returns the index of the first/last occurrence of the item in the list. Returns 0 if text is not found.";
|
||
En.LISTS_INLIST = "in list";
|
||
En.LISTS_IS_EMPTY_HELPURL = "https://github.com/google/blockly/wiki/Lists#is-empty";
|
||
En.LISTS_LENGTH_HELPURL = "https://github.com/google/blockly/wiki/Lists#length-of";
|
||
En.LISTS_LENGTH_TOOLTIP = "Returns the length of a list.";
|
||
En.LISTS_REPEAT_HELPURL = "https://github.com/google/blockly/wiki/Lists#create-list-with";
|
||
En.LISTS_REPEAT_TITLE = "create list with item %1 repeated %2 times";
|
||
En.LISTS_REPEAT_TOOLTIP = "Creates a list consisting of the given value repeated the specified number of times.";
|
||
En.LISTS_SET_INDEX_HELPURL = "https://github.com/google/blockly/wiki/Lists#in-list--set";
|
||
En.LISTS_SET_INDEX_INPUT_TO = "as";
|
||
En.LISTS_SET_INDEX_INSERT = "insert at";
|
||
En.LISTS_SET_INDEX_SET = "set";
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST = "Inserts the item at the start of a list.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM_END = "Inserts the item at the specified position in a list. #1 is the last item.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM_START = "Inserts the item at the specified position in a list. #1 is the first item.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT_LAST = "Append the item to the end of a list.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM = "Inserts the item randomly in a list.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_SET_FIRST = "Sets the first item in a list.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_SET_FROM_END = "Sets the item at the specified position in a list. #1 is the last item.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_SET_FROM_START = "Sets the item at the specified position in a list. #1 is the first item.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_SET_LAST = "Sets the last item in a list.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_SET_RANDOM = "Sets a random item in a list.";
|
||
En.LISTS_SPLIT_HELPURL = "https://github.com/google/blockly/wiki/Lists#splitting-strings-and-joining-lists";
|
||
En.LISTS_SPLIT_LIST_FROM_TEXT = "make list from text";
|
||
En.LISTS_SPLIT_TEXT_FROM_LIST = "make text from list";
|
||
En.LISTS_SPLIT_TOOLTIP_JOIN = "Join a list of texts into one text, separated by a delimiter.";
|
||
En.LISTS_SPLIT_TOOLTIP_SPLIT = "Split text into a list of texts, breaking at each delimiter.";
|
||
En.LISTS_SPLIT_WITH_DELIMITER = "with delimiter";
|
||
En.LISTS_TOOLTIP = "Returns true if the list is empty.";
|
||
En.LOGIC_BOOLEAN_FALSE = "false";
|
||
En.LOGIC_BOOLEAN_HELPURL = "https://github.com/google/blockly/wiki/Logic#values";
|
||
En.LOGIC_BOOLEAN_TOOLTIP = "Returns either true or false.";
|
||
En.LOGIC_BOOLEAN_TRUE = "true";
|
||
En.LOGIC_COMPARE_HELPURL = "https://en.wikipedia.org/wiki/Inequality_(mathematics)";
|
||
En.LOGIC_COMPARE_TOOLTIP_EQ = "Return true if both inputs equal each other.";
|
||
En.LOGIC_COMPARE_TOOLTIP_GT = "Return true if the first input is greater than the second input.";
|
||
En.LOGIC_COMPARE_TOOLTIP_GTE = "Return true if the first input is greater than or equal to the second input.";
|
||
En.LOGIC_COMPARE_TOOLTIP_GTE = "Return true if the first input is greater than or equal to the second input.";
|
||
En.LOGIC_COMPARE_TOOLTIP_LT = "Return true if the first input is smaller than the second input.";
|
||
En.LOGIC_COMPARE_TOOLTIP_LTE = "Return true if the first input is smaller than or equal to the second input.";
|
||
En.LOGIC_NEGATE_HELPURL = "https://github.com/google/blockly/wiki/Logic#not";
|
||
En.LOGIC_NEGATE_TITLE = "not";
|
||
En.LOGIC_NEGATE_TOOLTIP = "Returns true if the input is false. Returns false if the input is true.";
|
||
En.LOGIC_NULL = "null";
|
||
En.LOGIC_NULL_HELPURL = "https://en.wikipedia.org/wiki/Nullable_type";
|
||
En.LOGIC_NULL_TOOLTIP = "Returns null.";
|
||
En.LOGIC_OPERATION_AND = "and";
|
||
En.LOGIC_OPERATION_HELPURL = "https://github.com/google/blockly/wiki/Logic#logical-operations";
|
||
En.LOGIC_OPERATION_OR = "or";
|
||
En.LOGIC_OPERATION_TOOLTIP_AND = "Return true if both inputs are true.";
|
||
En.LOGIC_OPERATION_TOOLTIP_OR = "Return true if at least one of the inputs is true.";
|
||
En.LOGIC_TERNARY_CONDITION = "test";
|
||
En.LOGIC_TERNARY_HELPURL = "https://en.wikipedia.org/wiki/%3F:";
|
||
En.LOGIC_TERNARY_IF_FALSE = "if false";
|
||
En.LOGIC_TERNARY_IF_TRUE = "if true";
|
||
En.LOGIC_TERNARY_TOOLTIP = "Check the condition in 'test'. If the condition is true, returns the 'if true' value; otherwise returns the 'if false' value.";
|
||
En.MATH_ADDITION_SYMBOL = "+";
|
||
En.MATH_ARITHMETIC_HELPURL = "https://en.wikipedia.org/wiki/Arithmetic";
|
||
En.MATH_ARITHMETIC_TOOLTIP_ADD = "Return the sum of the two numbers.";
|
||
En.MATH_ARITHMETIC_TOOLTIP_DIVIDE = "Return the quotient of the two numbers.";
|
||
En.MATH_ARITHMETIC_TOOLTIP_MINUS = "Return the difference of the two numbers.";
|
||
En.MATH_ARITHMETIC_TOOLTIP_MULTIPLY = "Return the product of the two numbers.";
|
||
En.MATH_ARITHMETIC_TOOLTIP_POWER = "Return the first number raised to the power of the second number.";
|
||
En.MATH_ARITHMETIC_TOOLTIP_QUYU = "Returns the first number on the second number remainder.";
|
||
En.MATH_CHANGE_HELPURL = "https://en.wikipedia.org/wiki/Programming_idiom#Incrementing_a_counter";
|
||
En.MATH_CHANGE_INPUT_BY = "by";
|
||
En.MATH_CHANGE_TITLE_CHANGE = "change";
|
||
En.MATH_CHANGE_TOOLTIP = "Add a number to variable '%1'.";
|
||
En.MATH_CONSTANT_HELPURL = "https://en.wikipedia.org/wiki/Mathematical_constant";
|
||
En.MATH_CONSTANT_TOOLTIP = "Return one of the common constants: π (3.141…), e (2.718…), φ (1.618…), sqrt(2) (1.414…), sqrt(½) (0.707…), or ∞ (infinity).";
|
||
En.MATH_CONSTRAIN_HELPURL = "https://en.wikipedia.org/wiki/Clamping_%28graphics%29";
|
||
En.MATH_CONSTRAIN_TITLE = "constrain %1 low %2 high %3";
|
||
En.MATH_CONSTRAIN_TOOLTIP = "Constrain a number to be between the specified limits (inclusive).";
|
||
En.MATH_DIVISION_SYMBOL = "÷";
|
||
En.MATH_IS_DIVISIBLE_BY = "is divisible by";
|
||
En.MATH_IS_EVEN = "is even";
|
||
En.MATH_IS_NEGATIVE = "is negative";
|
||
En.MATH_IS_ODD = "is odd";
|
||
En.MATH_IS_POSITIVE = "is positive";
|
||
En.MATH_IS_PRIME = "is prime";
|
||
En.MATH_IS_TOOLTIP = "Check if a number is an even, odd, prime, whole, positive, negative, or if it is divisible by certain number. Returns true or false.";
|
||
En.MATH_IS_WHOLE = "is whole";
|
||
En.MATH_MODULO_HELPURL = "https://en.wikipedia.org/wiki/Modulo_operation";
|
||
En.MATH_MODULO_TITLE = "remainder of %1 ÷ %2";
|
||
En.MATH_MODULO_TOOLTIP = "Return the remainder from dividing the two numbers.";
|
||
En.MATH_MULTIPLICATION_SYMBOL = "×";
|
||
En.MATH_NUMBER_HELPURL = "https://en.wikipedia.org/wiki/Number";
|
||
En.MATH_NUMBER_TOOLTIP = "A number.";
|
||
En.MATH_ONLIST_HELPURL = "";
|
||
En.MATH_ONLIST_OPERATOR_AVERAGE = "average of list";
|
||
En.MATH_ONLIST_OPERATOR_MAX = "max of list";
|
||
En.MATH_ONLIST_OPERATOR_MEDIAN = "median of list";
|
||
En.MATH_ONLIST_OPERATOR_MIN = "min of list";
|
||
En.MATH_ONLIST_OPERATOR_MODE = "modes of list";
|
||
En.MATH_ONLIST_OPERATOR_RANDOM = "random item of list";
|
||
En.MATH_ONLIST_OPERATOR_STD_DEV = "standard deviation of list";
|
||
En.MATH_ONLIST_OPERATOR_SUM = "sum of list";
|
||
En.MATH_ONLIST_TOOLTIP_AVERAGE = "Return the average (arithmetic mean) of the numeric values in the list.";
|
||
En.MATH_ONLIST_TOOLTIP_MAX = "Return the largest number in the list.";
|
||
En.MATH_ONLIST_TOOLTIP_MEDIAN = "Return the median number in the list.";
|
||
En.MATH_ONLIST_TOOLTIP_MIN = "Return the smallest number in the list.";
|
||
En.MATH_ONLIST_TOOLTIP_MODE = "Return a list of the most common item(s) in the list.";
|
||
En.MATH_ONLIST_TOOLTIP_RANDOM = "Return a random element from the list.";
|
||
En.MATH_ONLIST_TOOLTIP_STD_DEV = "Return the standard deviation of the list.";
|
||
En.MATH_ONLIST_TOOLTIP_SUM = "Return the sum of all the numbers in the list.";
|
||
En.MATH_POWER_SYMBOL = "^";
|
||
En.MATH_RANDOM_FLOAT_HELPURL = "https://en.wikipedia.org/wiki/Random_number_generation";
|
||
En.MATH_RANDOM_FLOAT_TITLE_RANDOM = "random fraction";
|
||
En.MATH_RANDOM_FLOAT_TOOLTIP = "Return a random fraction between 0.0 (inclusive) and 1.0 (exclusive).";
|
||
En.MATH_RANDOM_INT_HELPURL = "https://en.wikipedia.org/wiki/Random_number_generation";
|
||
En.MATH_RANDOM_INT_TITLE = "random integer from %1 to %2";
|
||
En.MATH_RANDOM_INT_TOOLTIP = "Return a random integer between the two specified limits, inclusive.";
|
||
En.MATH_ROUND_HELPURL = "https://en.wikipedia.org/wiki/Rounding";
|
||
En.MATH_ROUND_OPERATOR_ROUND = "round";
|
||
En.MATH_ROUND_OPERATOR_ROUNDUP = "round up";
|
||
En.MATH_ROUND_TOOLTIP = "Numbers rounded up or down。";
|
||
En.MATH_SINGLE_HELPURL = "https://en.wikipedia.org/wiki/Square_root";
|
||
En.MATH_SINGLE_OP_ABSOLUTE = "absolute";
|
||
En.MATH_SINGLE_OP_ROOT = "square root";
|
||
En.MATH_ABS = 'abs';
|
||
En.MATH_SQ = 'sq';
|
||
En.MATH_SQRT = 'sqrt';
|
||
En.MATH_LOG = 'log';
|
||
En.MATH_SINGLE_TOOLTIP_ABS = "Return the absolute value of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_EXP = "Return e to the power of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_LN = "Return the natural logarithm of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_LOG10 = "Return the base 10 logarithm of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_NEG = "Return the negation of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_POW10 = "Return 10 to the power of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_ROOT = "Return the square root of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_SQ = "Return the square of a number.";
|
||
En.MATH_SINGLE_TOOLTIP_TOINT = "Returns the integer part a number.";
|
||
En.MATH_SINGLE_TOOLTIP_ROUND = "Returns the integer part a number using around.";
|
||
En.MATH_SINGLE_TOOLTIP_CEIL = "Returns the integer part a number using ceil.";
|
||
En.MATH_SINGLE_TOOLTIP_FLOOR = "Returns the integer part a number using floor.";
|
||
En.MATH_SUBTRACTION_SYMBOL = "-";
|
||
En.MATH_QUYU_SYMBOL = '%';
|
||
En.MATH_TRIG_ACOS = "acos";
|
||
En.MATH_TRIG_ASIN = "asin";
|
||
En.MATH_TRIG_ATAN = "atan";
|
||
En.MATH_TRIG_COS = "cos";
|
||
En.MATH_TRIG_HELPURL = "https://en.wikipedia.org/wiki/Trigonometric_functions";
|
||
En.MATH_TRIG_SIN = "sin";
|
||
En.MATH_TRIG_TAN = "tan";
|
||
En.MATH_TRIG_TOOLTIP_ACOS = "Return the arccosine of a number.";
|
||
En.MATH_TRIG_TOOLTIP_ASIN = "Return the arcsine of a number.";
|
||
En.MATH_TRIG_TOOLTIP_ATAN = "Return the arctangent of a number.";
|
||
En.MATH_TRIG_TOOLTIP_COS = "Return the cosine of a radian.";
|
||
En.MATH_TRIG_TOOLTIP_SIN = "Return the sine of a radian.";
|
||
En.MATH_TRIG_TOOLTIP_TAN = "Return the tangent of a radian.";
|
||
En.ME = "Me";
|
||
En.NEW_VARIABLE = "New variable...";
|
||
En.NEW_VARIABLE_TITLE = "New variable name:";
|
||
En.PROCEDURES_ALLOW_STATEMENTS = "allow statements";
|
||
En.PROCEDURES_CALLNORETURN_TOOLTIPETURN_HELPURL = "https://zh.wikipedia.org/wiki/子程序";
|
||
En.PROCEDURES_CALLNORETURN_TOOLTIP = "Run the user-defined function ' 1'.";
|
||
En.PROCEDURES_CALLRETURN_HELPURL = "https://zh.wikipedia.org/wiki/子程序";
|
||
En.PROCEDURES_CALLRETURN_TOOLTIP = "Run the user-defined function “%1” and use its output value.";
|
||
En.PROCEDURES_CALL_BEFORE_PARAMS = "with:";
|
||
En.PROCEDURES_CREATE_DO = "Create “%1” ";
|
||
En.PROCEDURES_DEFNORETURN_HELPURL = "https://en.wikipedia.org/wiki/Procedure_%28computer_science%29";
|
||
En.PROCEDURES_DEFNORETURN_PROCEDURE = "procedure";
|
||
En.PROCEDURES_DEFNORETURN_TITLE = "";
|
||
En.PROCEDURES_DEFNORETURN_TOOLTIP = "Creates a function with no output.";
|
||
En.PROCEDURES_DEFRETURN_HELPURL = "https://en.wikipedia.org/wiki/Procedure_%28computer_science%29";
|
||
En.PROCEDURES_DEFRETURN_RETURN = "return";
|
||
En.PROCEDURES_DEFRETURN_TOOLTIP = "Creates a function with an output.";
|
||
En.PROCEDURES_DEF_DUPLICATE_WARNING = "Warning: This function has duplicate parameters.";
|
||
En.PROCEDURES_HIGHLIGHT_DEF = "Highlight function definition";
|
||
En.PROCEDURES_IFRETURN_TOOLTIP = "If a value is true, then return a second value.";
|
||
En.PROCEDURES_IFRETURN_WARNING = "Warning: This block may be used only within a function definition.";
|
||
En.PROCEDURES_BEFORE_PARAMS = "with:";
|
||
En.PROCEDURES_MUTATORARG_TOOLTIP = "Add an input to the function.";
|
||
En.PROCEDURES_MUTATORCONTAINER_TITLE = "inputs";
|
||
En.PROCEDURES_MUTATORCONTAINER_TOOLTIP = "Add, remove, or reorder inputs to this function.";
|
||
En.RENAME_VARIABLE = "Rename variable...";
|
||
En.RENAME_VARIABLE_TITLE = "Rename all '%1' variables to:";
|
||
En.TEXT_APPEND_APPENDTEXT = "append text";
|
||
En.TEXT_WRITE_TEXT = "Write Text";
|
||
En.TEXT_APPEND_HELPURL = "https://github.com/google/blockly/wiki/Text#text-modification";
|
||
En.TEXT_APPEND_TO = "to";
|
||
En.TEXT_APPEND_TOOLTIP = "Append some text to variable '%1'.";
|
||
En.TEXT_CHANGECASE_HELPURL = "https://github.com/google/blockly/wiki/Text#adjusting-text-case";
|
||
En.TEXT_CHANGECASE_OPERATOR_LOWERCASE = "to lower case";
|
||
En.TEXT_CHANGECASE_OPERATOR_TITLECASE = "to Title Case";
|
||
En.TEXT_CHANGECASE_OPERATOR_UPPERCASE = "to UPPER CASE";
|
||
En.TEXT_CHANGECASE_TOOLTIP = "Return a copy of the text in a different case.";
|
||
En.TEXT_CHARAT_FIRST = "get first letter";
|
||
En.TEXT_CHARAT_FROM_END = "get letter # from end";
|
||
En.TEXT_CHARAT_FROM_START = "get letter #";
|
||
En.TEXT_CHARAT = "";
|
||
En.TEXT_CHARAT2 = "";
|
||
En.TEXT_CHARAT_HELPURL = "https://github.com/google/blockly/wiki/Text#extracting-text";
|
||
En.TEXT_CHARAT_INPUT_INTEXT = "in text";
|
||
En.TEXT_CHARAT_LAST = "get last letter";
|
||
En.TEXT_CHARAT_RANDOM = "get random letter";
|
||
En.TEXT_CHARAT_TAIL = "";
|
||
En.TEXT_CHARAT_TOOLTIP = "Returns the letter at the specified position.";
|
||
En.TEXT_CREATE_JOIN_ITEM_TOOLTIP = "Add an item to the text.";
|
||
En.TEXT_CREATE_JOIN_TITLE_JOIN = "join";
|
||
En.TEXT_CREATE_JOIN_TOOLTIP = "Add, remove, or reorder sections to reconfigure this text block.";
|
||
En.TEXT_GET_SUBSTRING_END_FROM_END = "to letter # from end";
|
||
En.TEXT_GET_SUBSTRING_END_FROM_START = "to letter #";
|
||
En.TEXT_GET_SUBSTRING_END_LAST = "to last letter";
|
||
En.TEXT_GET_SUBSTRING_HELPURL = "https://github.com/google/blockly/wiki/Text#extracting-a-region-of-text";
|
||
En.TEXT_GET_SUBSTRING_START_FIRST = "get substring from first letter";
|
||
En.TEXT_GET_SUBSTRING_START_FROM_END = "get substring from letter # from end";
|
||
En.TEXT_GET_SUBSTRING_START_FROM_START = "get substring from letter #";
|
||
En.TEXT_GET_SUBSTRING_TOOLTIP = "Returns a specified portion of the text.";
|
||
En.TEXT_INDEXOF_HELPURL = "https://github.com/google/blockly/wiki/Text#finding-text";
|
||
En.TEXT_INDEXOF_OPERATOR_FIRST = "find first occurrence of text";
|
||
En.TEXT_INDEXOF_OPERATOR_LAST = "find last occurrence of text";
|
||
En.TEXT_INDEXOF_TAIL = "";
|
||
En.TEXT_INDEXOF_TOOLTIP = "Returns the index of the first/last occurrence of first text in the second text. Returns 0 if text is not found.";
|
||
En.TEXT_ISEMPTY_HELPURL = "https://github.com/google/blockly/wiki/Text#checking-for-empty-text";
|
||
En.TEXT_ISEMPTY_TITLE = "%1 is empty";
|
||
En.LISTS_IS_EMPTY_TITLE = "%1 is empty";
|
||
En.TEXT_ISEMPTY_TOOLTIP = "Returns true if the provided text is empty.";
|
||
En.TEXT_JOIN_HELPURL = "https://github.com/google/blockly/wiki/Text#text-creation";
|
||
En.TEXT_JOIN_TITLE_CREATEWITH = "create text with";
|
||
En.TEXT_JOIN_TOOLTIP = "Create a piece of text by joining together any number of items.";
|
||
En.TEXT_LENGTH_HELPURL = "https://github.com/google/blockly/wiki/Text#text-modification";
|
||
En.TEXT_LENGTH_TITLE = "length of %1";
|
||
En.TEXT_LENGTH_TOOLTIP = "Returns the number of letters (including spaces) in the provided text.";
|
||
En.TEXT_PRINT_HELPURL = "https://github.com/google/blockly/wiki/Text#printing-text";
|
||
En.TEXT_PRINT_TITLE = "print %1";
|
||
En.TEXT_PRINT_TOOLTIP = "Write the specified text, number or other value.";
|
||
En.TEXT_PRINT_HEX_TOOLTIP = "Print the specified text, number or other value.";
|
||
En.TEXT_WRITE_TOOLTIP = "Print the specified number in hexadecimal format.";
|
||
En.TEXT_PROMPT_HELPURL = "https://github.com/google/blockly/wiki/Text#getting-input-from-the-user";
|
||
En.TEXT_PROMPT_TOOLTIP_NUMBER = "Prompt for user for a number.";
|
||
En.TEXT_PROMPT_TOOLTIP_TEXT = "Prompt for user for some text.";
|
||
En.TEXT_PROMPT_TYPE_TEXT = "prompt for text with message";
|
||
En.TEXT_TEXT_HELPURL = "https://en.wikipedia.org/wiki/String_(computer_science)";
|
||
En.TEXT_TEXT_TOOLTIP = "A letter, word, or line of text.";
|
||
En.TEXT_CHAR_TOOLTIP = "A character.";
|
||
En.TEXT_TRIM_HELPURL = "https://github.com/google/blockly/wiki/Text#trimming-removing-spaces";
|
||
En.TEXT_TRIM_OPERATOR_BOTH = "trim spaces from both sides of";
|
||
En.TEXT_TRIM_OPERATOR_LEFT = "trim spaces from left side of";
|
||
En.TEXT_TRIM_OPERATOR_RIGHT = "trim spaces from right side of";
|
||
En.VARIABLES_DEFAULT_NAME = "item";
|
||
En.VARIABLES_GET_CREATE_SET = "Create 'set %1'";
|
||
En.VARIABLES_GET_HELPURL = "https://github.com/google/blockly/wiki/Variables#get";
|
||
En.VARIABLES_GET_TAIL = "";
|
||
En.VARIABLES_GET_TITLE = "";
|
||
En.VARIABLES_GET_TOOLTIP = "Returns the value of this variable.";
|
||
En.VARIABLES_SET_CREATE_GET = "Create 'get %1'";
|
||
En.VARIABLES_SET_HELPURL = "https://github.com/google/blockly/wiki/Variables#set";
|
||
En.VARIABLES_SET_TAIL = "to";
|
||
En.VARIABLES_SET_TITLE = "set";
|
||
En.VARIABLES_SET_TOOLTIP = "Sets this variable to be equal to the input.";
|
||
En.PROCEDURES_DEFRETURN_TITLE = En.PROCEDURES_DEFNORETURN_TITLE;
|
||
En.LISTS_GET_SUBLIST_INPUT_IN_LIST = En.LISTS_INLIST;
|
||
En.LISTS_SET_INDEX_INPUT_IN_LIST = En.LISTS_INLIST;
|
||
En.PROCEDURES_DEFRETURN_PROCEDURE = En.PROCEDURES_DEFNORETURN_PROCEDURE;
|
||
En.VARIABLES_SET_ITEM = En.VARIABLES_DEFAULT_NAME;
|
||
En.LISTS_CREATE_WITH_ITEM_TITLE = En.VARIABLES_DEFAULT_NAME;
|
||
En.MATH_CHANGE_TITLE_ITEM = En.VARIABLES_DEFAULT_NAME;
|
||
En.VARIABLES_GET_ITEM = En.VARIABLES_DEFAULT_NAME;
|
||
En.PROCEDURES_DEFRETURN_DO = En.PROCEDURES_DEFNORETURN_DO;
|
||
En.LISTS_GET_INDEX_HELPURL = En.LISTS_INDEX_OF_HELPURL;
|
||
En.TEXT_CREATE_JOIN_ITEM_TITLE_ITEM = En.VARIABLES_DEFAULT_NAME;
|
||
En.CONTROLS_IF_MSG_THEN = En.CONTROLS_REPEAT_INPUT_DO;
|
||
En.LISTS_INDEX_OF_INPUT_IN_LIST = En.LISTS_INLIST;
|
||
En.PROCEDURES_CALLRETURN_CALL = En.PROCEDURES_CALLNORETURN_CALL;
|
||
En.LISTS_GET_INDEX_INPUT_IN_LIST = En.LISTS_INLIST;
|
||
En.CONTROLS_FOR_INPUT_DO = En.CONTROLS_REPEAT_INPUT_DO;
|
||
En.CONTROLS_FOREACH_INPUT_DO = En.CONTROLS_REPEAT_INPUT_DO;
|
||
En.CONTROLS_IF_IF_TITLE_IF = En.CONTROLS_IF_MSG_IF;
|
||
En.CONTROLS_WHILEUNTIL_INPUT_DO = En.CONTROLS_REPEAT_INPUT_DO;
|
||
En.CONTROLS_IF_ELSEIF_TITLE_ELSEIF = En.CONTROLS_IF_MSG_ELSEIF;
|
||
En.TEXT_APPEND_VARIABLE = En.VARIABLES_DEFAULT_NAME;
|
||
En.CONTROLS_IF_ELSE_TITLE_ELSE = En.CONTROLS_IF_MSG_ELSE;
|
||
En.MIXLY_PINMODE = 'pinMode';
|
||
En.MIXLY_PINMODEIN = 'INPUT';
|
||
En.MIXLY_PINMODEOUT = 'OUTPUT';
|
||
En.MIXLY_PINMODEPULLUP = 'PULLUP';
|
||
En.MIXLY_DECLARE = 'Declare';
|
||
En.MIXLY_AS = 'as';
|
||
En.MIXLY_VALUE = 'value';
|
||
En.MIXLY_VALUE2 = 'value';
|
||
En.MIXLY_MAP = 'Map ';
|
||
//En.MIXLY_MAP_INT = 'Map(int) ';
|
||
//En.MIXLY_MAP_FLOAT = 'Map(float) ';
|
||
En.MIXLY_MAP_FROM = 'from [';
|
||
En.MIXLY_MAP_TO = '] to [';
|
||
En.MIXLY_MILLIS = 'millis';
|
||
En.MIXLY_DELAY = 'Delay';
|
||
En.MIXLY_ATTACHINTERRUPT_PIN = 'attachInterrupt pin#';
|
||
En.MIXLY_DETACHINTERRUPT_PIN = 'detachInterrupt pin#';
|
||
En.MIXLY_ATTACHPININTERRUPT_PIN = 'attachPinInterrupt pin#';
|
||
En.MIXLY_DETACHPININTERRUPT_PIN = 'detachPinInterrupt pin#';
|
||
En.MIXLY_MODE = 'mode';
|
||
En.MIXLY_DO = 'do';
|
||
En.MIXLY_BUILDIN_LED = 'Build-in LED ';
|
||
En.MIXLY_EXTERN_LED = 'LED';
|
||
En.MIXLY_STAT = 'Stat';
|
||
En.MIXLY_DIGITALWRITE_PIN = 'DigitalWrite PIN#';
|
||
En.MIXLY_DIGITALREAD_PIN = 'DigitalRead PIN#';
|
||
En.MIXLY_ANALOGWRITE_PIN = 'AnalogWrite PIN#';
|
||
En.MIXLY_ANALOGREAD_PIN = 'AnalogRead PIN#';
|
||
En.MIXLY_SERIAL_WRITE = 'write';
|
||
En.MIXLY_SERIAL_PRINT = 'print';
|
||
En.MIXLY_SERIAL_PRINTLN = 'println';
|
||
En.MIXLY_SERIAL_FLUSH = 'flush';
|
||
En.MIXLY_STEP = 'step';
|
||
En.MIXLY_TONE = 'Tone PIN#';
|
||
En.MIXLY_TONE_NOTIMER = 'Tone (NO Timer)PIN#';
|
||
En.MIXLY_FREQUENCY = 'frequency';
|
||
En.MIXLY_CHANNEL = 'channel';
|
||
En.MIXLY_DURATION = 'duration';
|
||
En.MIXLY_NOTONE = 'noTone PIN#';
|
||
En.MIXLY_NOTONE_NOTIMER = 'noTone(NO Timer) PIN#';
|
||
En.MIXLY_BLOCKGROUP_CATEGORY = 'BlockGroup';
|
||
En.MIXLY_IR_RECEIVE = 'IRreceive PIN#';
|
||
En.MIXLY_IR_RECEIVE_ENABLE = 'enableIRIn PIN#';
|
||
En.MIXLY_IR_SEND_NEC1 = 'IRsend'
|
||
En.MIXLY_IR_SEND_NEC2 = ' PIN#'
|
||
En.MIXLY_IR_RECEIVE_RAW = 'IRreceive(Print RAW Data) PIN#';
|
||
En.MIXLY_IR_SEND_RAW = 'IRsend(RAW) PIN#'
|
||
En.LANG_MATH_TO_INT = 'toInt';
|
||
En.LANG_MATH_TO_ROUND = 'Round';
|
||
En.LANG_MATH_TO_CEIL = 'Ceil';
|
||
En.LANG_MATH_TO_FLOOR = 'Floor';
|
||
En.MIXLY_SERVO = 'Servo';
|
||
En.MIXLY_DEGREE_0_180 = 'Degree (0~180)';
|
||
En.MIXLY_READ_DEGREES = 'Read Degrees';
|
||
En.MIXLY_HIGH = 'HIGH';
|
||
En.MIXLY_LOW = 'LOW';
|
||
En.MIXLY_ON = 'ON';
|
||
En.MIXLY_OFF = 'OFF';
|
||
En.MIXLY_RISING = 'RISING';
|
||
En.MIXLY_FALLING = 'FALLING';
|
||
En.MIXLY_CHANGE = 'CHANGE';
|
||
En.MIXLY_I2C_MASTER_WRITE = 'I2C_Write device';
|
||
En.MIXLY_I2C_MASTER_READ2 = 'I2C Read';
|
||
En.MIXLY_I2C_MASTER_READ2 = 'I2C Read';
|
||
En.MIXLY_I2C_BYTES = 'bytes';
|
||
En.MIXLY_I2C_AVAILABLE = 'I2C_Slave_Read_isAvailable?';
|
||
En.MIXLY_I2C_SLAVE_ONRECEIVE = 'Register I2C Slave onReceive response Address';
|
||
En.MIXLY_I2C_HOWMANY = 'I2C Slave onReceive howMany';
|
||
En.MIXLY_I2C_SLAVE_ONREQUEST = 'Register I2C Slave onRequest response Address';
|
||
En.MIXLY_I2C_SLAVE_WRITE = 'I2C_Slave_Write';
|
||
En.MIXLY_I2C_SLAVE_WRITE_ARRAY = 'I2C_Slave_Write_Array';
|
||
En.MIXLY_I2C_SLAVE_WRITE_ARRAY_ARRAYNAME = 'Array';
|
||
En.MIXLY_I2C_SLAVE_WRITE_ARRAY_ARRAYLENGTH = 'Length';
|
||
En.LANG_CONTROLS_FOR_INPUT_WITH = 'count with';
|
||
En.LANG_CONTROLS_FOR_INPUT_VAR = 'x';
|
||
En.LANG_CONTROLS_FOR_INPUT_FROM = 'from';
|
||
En.LANG_CONTROLS_FOR_INPUT_TO = 'to';
|
||
En.LANG_CONTROLS_WHILEUNTIL_TITLE_REPEAT = 'repeat';
|
||
En.LANG_CONTROLS_WHILEUNTIL_OPERATOR_WHILE = 'while';
|
||
En.LANG_CONTROLS_WHILEUNTIL_OPERATOR_UNTIL = 'until';
|
||
En.LANG_CONTROLS_FLOW_STATEMENTS_INPUT_OFLOOP = 'of loop';
|
||
En.LANG_CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK = 'break out';
|
||
En.LANG_CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE = 'continue with next iteration';
|
||
En.LANG_CONTROLS_FLOW_STATEMENTS_WARNING = 'Warning:\n' + 'This block may only\n' + 'be used within a loop.';
|
||
En.LANG_MATH_INT = 'int';
|
||
En.LANG_MATH_LONG = 'long';
|
||
En.LANG_MATH_FLOAT = 'float';
|
||
En.LANG_MATH_BOOLEAN = 'boolean';
|
||
En.LANG_MATH_BYTE = 'byte';
|
||
En.LANG_MATH_CHAR = 'char';
|
||
En.LANG_MATH_STRING = 'string';
|
||
En.LANG_MATH_UNSIGNED_INT = 'unsigned int';
|
||
En.LANG_MATH_WORD = 'word';
|
||
En.LANG_MATH_UNSIGNED_LONG = 'unsigned long';
|
||
En.LANG_MATH_UNSIGNED_CHAR = 'unsigned char';
|
||
En.LANG_MATH_DOUBLE = 'double';
|
||
En.LANG_LISTS_GET_INDEX1 = 'get item at';
|
||
En.LANG_LISTS_GET_INDEX2 = '';
|
||
En.LANG_LISTS_GET_INDEX_TOOLTIP = 'Returns the value at the specified position in a list, index starts at 1.';
|
||
En.LANG_LISTS_SET_INDEX1 = 'set item at';
|
||
En.LANG_LISTS_SET_INDEX2 = 'to';
|
||
En.LANG_LISTS_SET_INDEX_TOOLTIP = 'Sets the value at the specified position in a list, index starts at 1.';
|
||
En.LANG_MATH_CONSTRAIN_INPUT_CONSTRAIN = 'Constrain';
|
||
En.LANG_MATH_CONSTRAIN_INPUT_LOW = 'between (low)';
|
||
En.LANG_MATH_CONSTRAIN_INPUT_HIGH = 'and (high)';
|
||
En.LANG_MATH_RANDOM_SEED = 'random seed';
|
||
En.LANG_MATH_RANDOM_INT_INPUT_FROM = 'random integer from';
|
||
En.LANG_MATH_RANDOM_INT_INPUT_TO = 'to';
|
||
En.MIXLY_JOYSTICK = 'Joystick';
|
||
En.MIXLY_POTENTIOMETER = 'Potentiometer';
|
||
En.MIXLY_SOUND = 'Sound';
|
||
En.MIXLY_TEMPERATURE = 'Temperature';
|
||
En.MIXLY_Humidity = 'Humidity';
|
||
En.MIXLY_Altitude = 'Altitude';
|
||
En.MIXLY_MAKELISTFROM = 'make list from text';
|
||
En.MIXLY_SPLITBYDOU = '';
|
||
En.MIXLY_SETUP = 'setup';
|
||
En.MIXLY_WARNING_INTERRUPT = 'This pin cannot be interrupted!';
|
||
En.MIXLY_CHAOSHENGBO = 'Ultrasonic ranging(cm) ';
|
||
En.MIXLY_WEIGHTSENSOR = 'Weight Module';
|
||
En.MIXLY_IR_RECEIVE_YES = 'Received';
|
||
En.MIXLY_IR_RECEIVE_NO = 'NotReceived';
|
||
En.MIXLY_TEXT_JOIN = 'join';
|
||
En.MIXLY_SERIAL_AVAILABLE = 'isAvailable?';
|
||
En.MIXLY_SERIAL_EVENT = 'serialEvent';
|
||
En.MIXLY_SERIAL_READSTR = 'readString';
|
||
En.MIXLY_SERIAL_READSTR_UNTIL = 'readStringUntil';
|
||
En.MIXLY_SERIAL_READ = 'read';
|
||
En.MIXLY_IR_RECIEVE_TOOLTIP = 'User-defined processing when infrared signals are received. ';
|
||
En.MIXLY_IR_SEND_NEC_TOOLTIP = 'Transmit specified type of infrared data';
|
||
En.MIXLY_IR_RECIEVE_RAW_TOOLTIP = 'Print infrared data in RAW format when an infrared signal is received. ';
|
||
En.MIXLY_IR_SEND_RAW_TOOLTIP = 'Transmit RAW infrared data, 4 parameters are pin number, array, array length, infrared signal frequency';
|
||
En.MIXLY_LIST_NAME = 'list';
|
||
En.MIXLY_LIST_LENGTH = 'listLength';
|
||
En.MIXLY_TO_INT = 'toInt';
|
||
En.MIXLY_TO_FLOAT = 'toFloat';
|
||
En.MIXLY_DATA = 'data';
|
||
En.MIXLY_BITS = 'bits';
|
||
En.MIXLY_PIN = 'PIN#';
|
||
En.MIXLY_GETTEMPERATUE = 'Return temperature';
|
||
En.MIXLY_GETHUMIDITY = 'getHumidity';
|
||
En.MIXLY_DHT11 = 'DHT11 PIN#';
|
||
En.MIXLY_LCD_RGB_BACKLIGHT = 'LCD RGB Backlight';
|
||
En.MIXLY_DF_LCD = 'LCD';
|
||
En.MIXLY_LCD_PRINT1 = 'print line1';
|
||
En.MIXLY_LCD_PRINT2 = 'print line2';
|
||
En.MIXLY_LCD_PRINT3 = 'print line3';
|
||
En.MIXLY_LCD_PRINT4 = 'print line4';
|
||
En.MIXLY_LCD_ROW = 'row';
|
||
En.MIXLY_LCD_COLUMN = 'column';
|
||
En.MIXLY_LCD_PRINT = 'print';
|
||
En.MIXLY_LCD_SETCOLOR = 'setColor';
|
||
En.MIXLY_LCD_STAT_CURSOR = 'Cursor';
|
||
En.MIXLY_LCD_STAT_NOCURSOR = 'noCursor';
|
||
En.MIXLY_LCD_STAT_BLINK = 'Blink';
|
||
En.MIXLY_LCD_STAT_NOBLINK = 'noBlink';
|
||
En.MIXLY_LCD_STAT_CLEAR = 'Clear';
|
||
En.MIXLY_LCD_NOBACKLIGHT = 'NoBackLight';
|
||
En.MIXLY_LCD_BACKLIGHT = 'BackLight';
|
||
En.MIXLY_NUMBER = 'number';
|
||
En.MIXLY_BLUETOOTH = 'Bluetooth';
|
||
En.MIXLY_BLUETOOTH_READ_STR = 'readString';
|
||
En.MIXLY_AVAILABLE = 'available?';
|
||
En.MIXLY_DATAPIN = 'dataPin#';
|
||
En.MIXLY_CLOCKPIN = 'clockPin#';
|
||
En.MIXLY_BITORDER = 'bitOrder';
|
||
En.MIXLY_MSBFIRST = 'MSBFIRST';
|
||
En.MIXLY_LSBFIRST = 'LSBFIRST';
|
||
En.MIXLY_TOSTRING = 'toString';
|
||
En.MIXLY_TOCHAR = 'Ascii to Char';
|
||
En.MIXLY_TOASCII = 'Char to Ascii';
|
||
En.MIXLY_STOP = 'stop';
|
||
En.MIXLY_PULSEIN = 'pulseIn(μs) PIN#';
|
||
En.MIXLY_PULSEIN_STAT = 'status';
|
||
En.MIXLY_PULSEIN_TIMEOUT = 'timeout(μs)';
|
||
En.MIXLY_MAX = 'max';
|
||
En.MIXLY_MIN = 'min';
|
||
En.MIXLY_WRITE_SD_FILE = 'Write SD File';
|
||
En.MIXLY_WRITE_SPIFFS_FILE = 'Write SPIFFS File';
|
||
En.MIXLY_SD_DATA = 'Data';
|
||
En.MIXLY_SD_NEWLINE = 'NewLine';
|
||
En.MIXLY_EEPROM_WRITE_LONG = 'Write(long) EEPROM address';
|
||
En.MIXLY_EEPROM_READ_LONG = 'Read(long) EEPROM address';
|
||
En.MIXLY_EEPROM_WRITE_BYTE = 'Write(byte) EEPROM address';
|
||
En.MIXLY_EEPROM_READ_BYTE = 'Read(byte) EEPROM address';
|
||
En.MIXLY_TRAFFIC_LED = 'Set Traffic LED';
|
||
En.MIXLY_EAST = 'EAST';
|
||
En.MIXLY_SOUTH = 'SOUTH';
|
||
En.MIXLY_WEST = 'WEST';
|
||
En.MIXLY_NORTH = 'NORTH';
|
||
En.MIXLY_BUTTON = 'Button';
|
||
En.MIXLY_UP = 'UP';
|
||
En.MIXLY_DOWN = 'DOWN';
|
||
En.MIXLY_LEFT = 'LEFT';
|
||
En.MIXLY_RIGHT = 'RIGHT';
|
||
En.MIXLY_MID = 'MID';
|
||
En.MIXLY_IS_PRESSED = 'is being pressed';
|
||
En.LANG_INOUT_DIGITAL_WRITE_TOOLTIP = 'Write digital value to a specific Port';
|
||
En.MIXLY_FORWARD = 'run forward';
|
||
En.MIXLY_BACKWARD = 'run backward';
|
||
En.MIXLY_TURNLEFT = 'turn left';
|
||
En.MIXLY_TURNRIGHT = 'turn right';
|
||
En.MIXLY_RUNTIME = 'System running time';
|
||
En.MIXLY_LED_ON_BOARD = 'led on board';
|
||
En.MIXLY_ALL = 'all';
|
||
En.MIXLY_SET_LED = 'Set LED';
|
||
En.MIXLY_SHOW_FACE = 'Show face';
|
||
En.MIXLY_SHOW_FACE_TEXT = 'characters:';
|
||
En.MIXLY_SHOW_FACE_TIME = 'time';
|
||
En.MIXLY_SETTING = 'set';
|
||
En.MIXLY_LCD_ADDRESS = 'address';
|
||
En.MIXLY_TOOLTIP_INOUT_HIGHLOW = 'Returns high or low voltage.';
|
||
En.MIXLY_TOOLTIP_INOUT_DIGITAL_READ = 'Returns digital value of a specific Port';
|
||
En.MIXLY_TOOLTIP_INOUT_ANALOG_WRITE_SET = 'Set Pin Period';
|
||
En.MIXLY_TOOLTIP_INOUT_ANALOG_READ = 'Returns the value of the specified pin (0 ~ 1023)';
|
||
En.MIXLY_TOOLTIP_INOUT_ATTACHINTERRUPT = 'Set the interrupt for the specified pin';
|
||
En.MIXLY_TOOLTIP_INOUT_DETACHINTERRUPT = 'Cancel the interrupt of the specified pin';
|
||
En.MIXLY_TOOLTIP_CONTROL_SETUP = 'Initialization operation (the content is only executed once)';
|
||
En.MIXLY_TOOLTIP_CONTROL_DELAY = 'Delays specific time';
|
||
En.MIXLY_TOOLTIP_CONTROL_MILLIS = 'Returns the system running time';
|
||
En.MIXLY_TOOLTIP_VARIABLES_DECLARE = 'Declare and initialize a variable';
|
||
En.MIXLY_TOOLTIP_MATH_MAX = 'Returns the larger number';
|
||
En.MIXLY_TOOLTIP_MATH_MIN = 'Returns the smaller number';
|
||
En.MIXLY_TOOLTIP_MATH_MAP = 'Maps a number from the first interval to the second interval.';
|
||
En.MIXLY_TOOLTIP_TEXT_JOIN = 'Creates a piece of text by joining together two piece of text.';
|
||
En.MIXLY_TOOLTIP_TEXT_TOTEXT = 'Converts a number into a string.';
|
||
En.MIXLY_TOOLTIP_TEXT_TOCHAR = 'Returns the char corresponding to an ASCII code.';
|
||
En.MIXLY_TOOLTIP_TEXT_TOASCII = 'Returns the ASCII code corresponding to a char.';
|
||
En.MIXLY_TOOLTIP_TEXT_TOINT = 'Converts a string into an integer.';
|
||
En.MIXLY_TOOLTIP_TEXT_TOFLOAT = 'Converts a string into an float.';
|
||
En.MIXLY_TOOLTIP_TEXT_TOBYTE = 'Convert a string to a byte';
|
||
En.MIXLY_TOOLTIP_LISTS_CREATE_WITH_TEXT = "Creates a list from a text.";
|
||
En.MIXLY_TOOLTIP_LOGIT_TRUEORFALSE = 'If the first parameter is true, return the second parameter, otherwise return the third parameter. ';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_SERIAL_AVAILABLE = 'If the serial port has data to read, return true, otherwise return false. ';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_SERIAL_READ_STR = 'Returns a string from the serial port. ';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_SERIAL_READ_INT = 'Returns a integer in serial port.';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_SERIAL_READ_FLOAT = 'Returns a float in serial port.';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_CHAOSHENGBO = 'Returns the distance of ultrasonic sensor measured.';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_GET_TEM = 'Returns the temperature of dht11 sensor measured.';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_GET_TEM_HUM = 'Return the temperature and humidity measured by the temperature and humidity sensor.';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_SERVO_MOVE = 'Set the rotation angle of the servo (0 ~ 180 °) and the delay time';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_SERVO_READ = 'Returns the angle at which the servo is currently stopped. ';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_TONE = 'Play the sound at the specified frequency. ';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_TONE2 = 'Play the sound at the specified frequency and duration. ';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_NOTONE = 'Stop playing sound.';
|
||
En.MIXLY_TOOLTIP_INOUT_pinMode = 'Change pin mode';
|
||
En.MIXLY_TOOLTIP_INOUT_pulseIn = 'Get the period of the last pulse of a pin (microseconds)';
|
||
En.MIXLY_TOOLTIP_INOUT_pulseIn2 = 'Get the period of the last pulse of a pin (microseconds, timeout parameter can be set)';
|
||
En.MIXLY_TOOLTIP_INOUT_shiftout = 'Output data on the pins in a serial manner, which is equivalent to synchronous serial communication in the general sense';
|
||
En.MIXLY_TOOLTIP_CONTROL_MSTIMER2_STOP = 'MsTimer2 stop';
|
||
En.MIXLY_TOOLTIP_CONTROL_MSTIMER2_START = 'MsTimer2 start';
|
||
En.MIXLY_TOOLTIP_CONTROL_MSTIMER2_STOP = 'MsTimer2 stop';
|
||
En.MIXLY_TOOLTIP_CONTROL_END_PROGRAM = 'Halt this program';
|
||
En.MIXLY_TOOLTIP_CONTROL_ALLOW_INTERRUPT = 'Enable interruption';
|
||
En.MIXLY_TOOLTIP_SCOOP = 'Arduino Multithreading';
|
||
En.MIXLY_TOOLTIP_SCOOP_YIELD = 'Start executing multithreaded tasks';
|
||
En.MIXLY_TOOLTIP_SCOOP_SLEEP = 'Delay specified time (for multithreading only)';
|
||
En.MIXLY_TOOLTIP_MATH_RANDOM_SEED = 'Set random number seeds';
|
||
En.MIXLY_TOOLTIP_TEXT_FIND_CHAR_AT = 'find substring %1 at string';
|
||
En.MIXLY_TOOLTIP_TEXT_EQUALS_STARTS_ENDS = 'Returns whether the string %1 %2';
|
||
En.MIXLY_TOOLTIP_SERIAL_BEGIN = 'Initialize Serial Port and Set Serial Port Communication Baud Rate';
|
||
En.MIXLY_TOOLTIP_SERIAL_READSTRUNITL = 'Read the string from the serial port until encounter %1';
|
||
En.MIXLY_TOOLTIP_SERIAL_FLUSH = 'Clear data in serial buffer';
|
||
En.MIXLY_TOOLTIP_SOFTSERIAL = 'Simulate digital pins #%1 and #%2 into serial communication pins';
|
||
En.MIXLY_TOOLTIP_SERIALEVENT = 'Execute certain commands by interruption when receiving information at serial ports';
|
||
En.MIXLY_TOOLTIP_IR_ENABLE = '';
|
||
En.MIXLY_TOOLTIP_I2C_MASTER_WRITE = 'I2C main device sends data. The parameters are the address of the main device and the value to be sent.';
|
||
En.MIXLY_TOOLTIP_I2C_MASTER_READ = 'I2C main device reads data. The parameters are the address of the main device and the byte length of the content to be read.';
|
||
En.MIXLY_TOOLTIP_I2C_MASTER_READ2 = 'Return data read from I2C main device';
|
||
En.MIXLY_TOOLTIP_I2C_AVAILABLE = 'Returns whether I2C device data was successfully read';
|
||
En.MIXLY_TOOLTIP_I2C_SLAVE_ONRECEIVE = 'The I2C slave receives the clock and data signals generated by the host and performs the corresponding operation';
|
||
En.MIXLY_TOOLTIP_I2C_HOWMANY = 'Return the number of bytes received by the I2C slave';
|
||
En.MIXLY_TOOLTIP_I2C_SLAVE_ONREQUEST = 'I2C slave sends according to the clock and data signals generated by the master and performs the corresponding operation';
|
||
En.MIXLY_TOOLTIP_I2C_SLAVE_WRITE = 'I2C send byte';
|
||
En.MIXLY_TOOLTIP_I2C_SLAVE_WRITE_ARRAY = 'I2C Send Array';
|
||
En.MIXLY_TOOLTIP_SPI_TRANSFER = 'As the master, transfer data to the slave via pin% 1 in SPI mode';
|
||
En.MIXLY_TOOLTIP_RFID_INIT = 'Initialize RFID card reader, parameters are data line pin number, clock line pin number, main output slave output line pin number and main input slave output first pin number';
|
||
En.MIXLY_TOOLTIP_RFID_ON = 'Execute some instructions when RFID reads data';
|
||
En.MIXLY_TOOLTIP_RFID_READ = 'Return the card number read by RFID';
|
||
En.MIXLY_TOOLTIP_RFID_IN = 'Execute some instructions when RFID reads specific data';
|
||
En.MIXLY_TOOLTIP_RFID_WRITEBLOCK = 'Write data to the data block in the electronic tag';
|
||
En.MIXLY_TOOLTIP_RFID_READBLOCK = 'Read data from the data block in the electronic tag';
|
||
En.MIXLY_TOOLTIP_RFID_OFF = 'Stop RFID devices from reading data';
|
||
En.MIXLY_TOOLTIP_STORE_SDWRITE = 'Write files to SD card';
|
||
En.MIXLY_TOOLTIP_STORE_EEPROM_WRITELONG = 'Write Long Integer Data to EEPROM specific address';
|
||
En.MIXLY_TOOLTIP_STORE_EEPROM_READLONG = 'Read long integer data from specific address of EEPROM';
|
||
En.MIXLY_TOOLTIP_STORE_EEPROM_WRITEBYTE = 'Write byte data to EEPROM specific address';
|
||
En.MIXLY_TOOLTIP_STORE_EEPROM_READBYTE = 'Read byte data from specific address of EEPROM';
|
||
En.MIXLY_TOOLTIP_GPS_INIT = 'Initialize GPS equipment with parameters of GPS communication pin and baud rate';
|
||
En.MIXLY_TOOLTIP_GPS_DATA_AVAILABLE = 'Returns whether GPS data is valid';
|
||
En.MIXLY_TOOLTIP_GPS_GETDATA = 'GET %1 data from GPS satellites';
|
||
En.MIXLY_TOOLTIP_LM35 = 'Obtaining the Temperature Return from LM35 Sensor';
|
||
En.MIXLY_TOOLTIP_DS18 = 'Obtain the temperature value returned by DS18B20 sensor';
|
||
En.MIXLY_TOOLTIP_DS1302_INIT = 'Initialize DS1302 RTC clock module with parameters of reset line pin number, data line pin number and clock line pin number.';
|
||
En.MIXLY_TOOLTIP_DS1307_INIT = 'Initialize DS1307 RTC clock module with data line pin number and clock line pin number as parameters';
|
||
En.MIXLY_TOOLTIP_RTC_GETTIME = 'Get %1 from RTC clock module';
|
||
En.MIXLY_TOOLTIP_ADXL345 = 'Get %1 returned by ADXL345 gravity induction module';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_SERVO_WRITEMICROSECONDS = 'Set the rotating time of servo (take the value of parameters as [1000,2000])';
|
||
En.MIXLY_TOOLTIP_TONE_NOTE = 'Returns the frequency corresponding to the phonetic name';
|
||
En.MIXLY_TOOLTIP_STEPPER_STEP = 'Initialize two-pin stepper motor';
|
||
En.MIXLY_TOOLTIP_STEPPER_STEP2 = 'Initialize four-pin stepper motor';
|
||
En.MIXLY_TOOLTIP_STEPPER_MOVE = 'Set the number of movement steps of the stepper motor';
|
||
En.MIXLY_TOOLTIP_LCD_INIT = 'Initialize the LCD display and set the address';
|
||
En.MIXLY_TOOLTIP_LCD_INIT2 = 'Initialize the LCD display, specify the clock and data lines to connect the pins and set the address';
|
||
En.MIXLY_TOOLTIP_LCD_INIT3 = 'Initialize the LCD display, specify all connection pins and set the address';
|
||
En.MIXLY_TOOLTIP_LCD_PRINT = 'Branch printing on LCD display';
|
||
En.MIXLY_TOOLTIP_LCD_PRINT2 = 'Display the specified content starting from line% 1 and column% 2 of the LCD display';
|
||
En.MIXLY_TOOLTIP_LCD_POWER = 'Set the display style of the LCD display';
|
||
En.MIXLY_TOOLTIP_OLED_DRAW4STRING = 'OLED Display Line Printing';
|
||
En.MIXLY_TOOLTIP_OLED_PRINT = 'Display the specified charactert at line %1, column %2 of the OLED display screen';
|
||
En.MIXLY_TOOLTIP_RGB_DISPLAY2 = 'Set the color of the specify lamp on RGB color lamp module';
|
||
En.MIXLY_TOOLTIP_4digitdisplay_power = 'Set TM1650 Four-digit Tube Display Mode';
|
||
En.MIXLY_TOOLTIP_4digitdisplay_displayString = 'TM1650 four-digit tube display string (scroll over four digits)';
|
||
En.MIXLY_TOOLTIP_4digitdisplay_showDot = 'Display decimal point at specified position of TM1650 four-digit digital tube';
|
||
En.MIXLY_TOOPTIP_4DIGITDISPLAY_TM1637_BRIGHTNESS = 'Set the brightness of TM1637(0-100)';
|
||
En.MIXLY_DISPLAY_TM1637_Time_Point = 'Time Point Set';
|
||
En.MIXLY_TOOPTIP_Matrix_HK16T33_INIT = 'Initialize HK16T33 8*8 Matrix Screen';
|
||
En.MIXLY_TOOPTIP_Matrix_HK16T33_ROTATION = 'Rotate Matrix Screen Display Direction';
|
||
En.MIXLY_TOOPTIP_Matrix_HK16T33_TEXT = 'Display one character in turn at a time';
|
||
En.MIXLY_TOOPTIP_Matrix_HK16T33_LEDARRAY = 'Light he corresponding position on the dot matrix screen';
|
||
En.MIXLY_TOOPTIP_Matrix_HK16T33_CLEAR = 'Clear up the content on the dot matrix screen';
|
||
En.MIXLY_TOOPTIP_Matrix_HK16T33_DISPLAYCHAR = 'Generate dot-matrix display content from arrays';
|
||
En.MIXLY_TOOLTIP_ETHERNET_INIT = 'Start the Ethernet service. The parameter is the MAC address of the Ethernet expansion card. Return 1 indicates successful startup and 0 indicates failure.';
|
||
En.MIXLY_TOOLTIP_ETHERNET_MACADDRESS = 'MAC address in pattern of XX-XX-XX-XX-XX-XX-XX, X in any hexadecimal digit';
|
||
En.MIXLY_TOOLTIP_ETHERNET_LOCALIP = 'Return to the local IP address';
|
||
En.MIXLY_TOOLTIP_ETHERNET_CONNECT = 'Connect to remote server, return 1 indicates successful start, others indicate failure';
|
||
En.MIXLY_TOOLTIP_ETHERNET_STOP = 'Disconnect from server';
|
||
En.MIXLY_TOOLTIP_ETHERNET_CONNECTED = 'Returns whether a server has been connected';
|
||
En.MIXLY_TOOLTIP_ETHERNET_CLIENT_AVAILABLE = 'Returns whether there is available data sent by the server';
|
||
En.MIXLY_TOOLTIP_ETHERNET_CLIENT_PRINT = 'Print data to the server that a client is connected to. Prints numbers as a sequence of digits, each an ASCII character (e.g. the number 123 is sent as the three characters \'1\', \'2\', \'3\').';
|
||
En.MIXLY_TOOLTIP_ETHERNET_CLIENT_PRINTLN = 'Print data, followed by a carriage return and newline, to the server a client is connected to. Prints numbers as a sequence of digits, each an ASCII character (e.g. the number 123 is sent as the three characters \'1\', \'2\', \'3\').';
|
||
En.MIXLY_TOOLTIP_ETHERNET_CLIENT_PRINTLN = 'Print data, followed by a carriage return and newline, to the server a client is connected to. Prints numbers as a sequence of digits, each an ASCII character (e.g. the number 123 is sent as the three characters \'1\', \'2\', \'3\').';
|
||
En.MIXLY_TOOLTIP_ETHERNET_CLIENT_READ = 'Read the next byte received from the server the client is connected to';
|
||
En.MIXLY_TOOLTIP_VARIABLES_CHANGE = 'Casting a constant or variable';
|
||
En.MIXLY_TOOLTIP_MLX90614_GET_DATA = 'MLX90614 infrared temperature sensor obtains temperature, and the type of data returned is float';
|
||
En.MIXLY_BUTTON_PRESSED = 'Pressed';
|
||
En.MIXLY_BUTTON_RELEASED = 'Released';
|
||
En.MIXLY_BUTTON_HOLD = 'Hold';
|
||
En.TO_SPI_SLAVE_PIN = 'To SPI Slave PIN#';
|
||
En.SPI_TRANSFER = 'transfer';
|
||
En.MIXLY_SERIAL_BEGIN = 'baud rate';
|
||
En.MIXLY_SERIALBT_INIT = 'ESP32 Bluetooth Name';
|
||
En.MIXLY_SERIALBT_AVAILABLE = 'ESP32 Bluetooth readable';
|
||
En.MIXLY_SERIALBT_READ = 'ESP32 Bluetooth Data';
|
||
En.MIXLY_SERIALBT_WRITE = 'ESP32 Bluetooth Send Data';
|
||
En.MIXLY_ESP32_RUNNING_CORE = 'ESP32 Dual Core';
|
||
En.MIXLY_CONTROL_CORE_DELAY = 'ESP32 Dual Core Delay';
|
||
En.MIXLY_ESP32_RUNNING_CORE_PRIORITY = 'Priority';
|
||
En.MIXLY_STEPPER = 'Stepper';
|
||
En.MIXLY_STEPPER_SETUP_STEPPER = 'Setup Stepper';
|
||
En.MIXLY_STEPPER_PIN1 = 'PIN1#';
|
||
En.MIXLY_STEPPER_PIN2 = 'PIN2#';
|
||
En.MIXLY_STEPPER_PIN3 = 'PIN3#';
|
||
En.MIXLY_STEPPER_PIN4 = 'PIN4#';
|
||
En.MIXLY_STEPSPERREVOLUTION = 'steps per revolution';
|
||
En.MIXLY_STEPPER_SET_SPEED = 'setSpeed';
|
||
En.MIXLY_STEPPER_GET_SPEED = 'getSpeed';
|
||
En.MIXLY_STEPPER_STEP = 'step';
|
||
En.MIXLY_ETHERNET_BEGIN = 'Begin (DHCP)';
|
||
En.MIXLY_ETHERNET = 'Ethernet';
|
||
En.MIXLY_ETHERNET2 = 'Ethernet2';
|
||
En.MIXLY_ETHERNET_MAC_ADDRESS = 'MAC Address';
|
||
En.MIXLY_ETHERNET_LOCALIP = 'localIP';
|
||
En.MIXLY_ETHERNET_CLINET_CONNECT_SERVER = 'Clinet.Connect Host';
|
||
En.MIXLY_ETHERNET_CLINET_PORT = 'Port';
|
||
En.MIXLY_ETHERNET_CLINET_STOP = 'Client.stop';
|
||
En.MIXLY_ETHERNET_CLINET_CONNECTED = 'Client.connected';
|
||
En.MIXLY_ETHERNET_CLINET_AVAILABLE = 'Client.available';
|
||
En.MIXLY_ETHERNET_CLINET_PRINT = 'Client.print';
|
||
En.MIXLY_ETHERNET_CLINET_PRINTLN = 'Client.println';
|
||
En.MIXLY_ETHERNET_CLINET_READ = 'Client.read';
|
||
En.MIXLY_ETHERNET_CLINET_GET_REQUEST = 'GET Request';
|
||
En.MIXLY_ETHERNET_CLINET_URL = 'URL';
|
||
En.MIXLY_ETHERNET_CLINET_SERVER = 'Host';
|
||
En.MIXLY_TEMP = 'Temperature Sensor';
|
||
En.MIXLY_DS18B20 = 'DS18B20 PIN#';
|
||
En.MIXLY_DS18B20_C = '°C';
|
||
En.MIXLY_DS18B20_F = '°F';
|
||
En.MIXLY_GPS_INIT = 'GPS init';
|
||
En.MIXLY_GPS_DATA_AVAILABLE = 'GPS data is available';
|
||
En.MIXLY_GPS_DATA_ENCODE = 'GPS encode data successful';
|
||
En.MIXLY_GPS_LOCATION = 'location';
|
||
En.MIXLY_GPS_DATE = 'date';
|
||
En.MIXLY_GPS_TIME = 'time';
|
||
En.MIXLY_GPS_ISVALID = 'isValid';
|
||
En.MIXLY_GPS_GET = 'GPS get';
|
||
En.MIXLY_GPS_LOCATION_LAT = 'location-latitude';
|
||
En.MIXLY_GPS_LOCATION_LNG = 'location-longitude';
|
||
En.MIXLY_GPS_DATE_YEAR = 'date-year';
|
||
En.MIXLY_GPS_DATE_MONTH = 'date-month';
|
||
En.MIXLY_GPS_DATE_DAY = 'date-day';
|
||
En.MIXLY_GPS_TIME_HOUR = 'time-hour';
|
||
En.MIXLY_GPS_TIME_MINUTE = 'time-minute';
|
||
En.MIXLY_GPS_TIME_SECOND = 'time-second';
|
||
En.MIXLY_GPS_TIME_CENTISECOND = 'time-centisecond';
|
||
En.MIXLY_PARAMS = 'parameters';
|
||
En.MIXLY_MSTIMER2_EVERY = 'every';
|
||
En.MIXLY_MSTIMER2_DO = 'do';
|
||
En.MIXLY_MSTIMER2_START = 'start';
|
||
En.MIXLY_CONTROL_INTERRUPTS = 'interrupts';
|
||
En.MIXLY_CONTROL_NOINTERRUPTS = 'nointerrupts';
|
||
En.MIXLY_CONTROL_SCoop_loop = 'loop';
|
||
En.MIXLY_CONTROL_SCoop_yield = 'yield SCoop tasks';
|
||
En.MIXLY_CONTROL_SCoop_sleep = 'SCoop sleep(only for SCoop)';
|
||
En.MIXLY_WARNING_NOT_DECLARE = 'This variable is not declared!';
|
||
En.MIXLY_LENGTH = "get length";
|
||
En.MIXLY_EQUALS = 'equals';
|
||
En.MIXLY_STARTSWITH = 'startsWith';
|
||
En.MIXLY_ENDSWITH = 'ends With';
|
||
En.MIXLY_COMPARETO = 'compareTo';
|
||
En.MIXLY_COMPARETO_HELP = 'compare based on dictory, equal retrun 0 ,bigger return positive,else return negative';
|
||
En.UNDO = "Undo";
|
||
En.REDO = "Redo";
|
||
En.MIXLY_CONTROL_END_PROGRAM = "end program";
|
||
En.MIXLY_CONTROL_NOTES = 'Notes:';
|
||
En.texttodisplay = "texts to display:";
|
||
En.OLEDDISPLAY = "display";
|
||
En.rawx = "raw x(127 max)";
|
||
En.liney = "line y(63 max)";
|
||
En.line1 = 'line1';
|
||
En.line2 = "line2";
|
||
En.line3 = "line3";
|
||
En.line4 = "line4";
|
||
En.num1 = "num 1";
|
||
En.num2 = "num 2";
|
||
En.num3 = "num 3";
|
||
En.num4 = "num 4";
|
||
En.MIXLY_RGB_INIT = 'RGB Init';
|
||
En.MIXLY_RGB_SET_BRIGHTNESS = 'RGB Brightness';
|
||
En.MIXLY_RGB_SET_COLOR = 'RGB Color';
|
||
En.MIXLY_RGB_SHOW = 'RGB show';
|
||
En.MIXLY_RGB = 'RGB';
|
||
En.MIXLY_CHASE = 'chase';
|
||
En.MIXLY_RAINBOW = 'rainbow';
|
||
En.MIXLY_RGB_NUM = 'NO.';
|
||
En.MIXLY_RGB_COUNT = 'COUNT';
|
||
En.MIXLY_RGB_R = 'R';
|
||
En.MIXLY_RGB_G = 'G';
|
||
En.MIXLY_RGB_B = 'B';
|
||
En.MIXLY_RGBdisplay_rgb_rainbow1 = 'conversion switch time';
|
||
En.MIXLY_RGBdisplay_rgb_rainbow2 = 'cycle switch time';
|
||
En.MIXLY_RGB_DISPLAY_RAINBOW_TYPE_1 = 'Normal';
|
||
En.MIXLY_RGB_DISPLAY_RAINBOW_TYPE_2 = 'Gradient';
|
||
En.MIXLY_RGB_display_rgb_rainbow3 = 'rainbow';
|
||
En.MIXLY_4DIGITDISPLAY = 'Four digit tube';
|
||
En.MIXLY_4DIGITDISPLAY_NOMBER1 = '';
|
||
En.MIXLY_4DIGITDISPLAY_NOMBER2 = '';
|
||
En.MIXLY_4DIGITDISPLAY_DOT = 'Dot';
|
||
En.MIXLY_4DIGITDISPLAY_ON = 'ON';
|
||
En.MIXLY_4DIGITDISPLAY_OFF = 'OFF';
|
||
En.MIXLY_0DEGREE = '0';
|
||
En.MIXLY_90DEGREE = '90';
|
||
En.MIXLY_180DEGREE = '180';
|
||
En.MIXLY_270DEGREE = '270';
|
||
En.MIXLY_MATRIX_TYPE = 'matrix Type';
|
||
En.MIXLY_MATRIX_NAME = 'Matrix Name';
|
||
En.MIXLY_MAX7219_INIT_NUM = 'Num';
|
||
En.MIXLY_MAX7219_PUTSTR = 'Show';
|
||
En.MIXLY_SPEED = 'Speed';
|
||
En.MIXLY_BRIGHTNESS = 'Brightness';
|
||
En.MIXLY_MAX7219_BRIGHTNESS_TOOLTIP = ''
|
||
En.MIXLY_MAX7219_LEDARRAY = 'LED Array';
|
||
En.MIXLY_MAX7219_INIT = 'MAX7219 matrix Init';
|
||
En.MIXLY_MAX7219_IMG = 'image';
|
||
En.MIXLY_MAX7219_HDISPALY = 'Row';
|
||
En.MIXLY_MAX7219_VDISPALY = 'Col';
|
||
En.MAX7219_FILLSCREEN_ON = 'All ON';
|
||
En.MAX7219_FILLSCREEN_OFF = 'All Off';
|
||
En.MAX7219_SHUTDOWN_ON = 'Turn Off';
|
||
En.MAX7219_SHUTDOWN_OFF = 'Turn On';
|
||
En.MIXLY_MAX7219_NO = 'NO';
|
||
En.MAX7219_INIT_TOOLTIP = 'Init Matrix';
|
||
En.MIXLY_TOOPTIP_Matrix_MAX7219_STRING = 'Display each character in a string one by one at a certain speed';
|
||
En.MIXLY_TOOPTIP_Matrix_MAX7219_PREDEFARR = 'Returns an array corresponding to the predefined pattern';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637 = 'TM1637';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_DISPLAYPRINT = 'TM1637 Display';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_DISPLAYSTRING_TIP = '';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_TIP = 'Must be initialized with two pins before use, CLK is the clock pin, and DIO is the data pin';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_DISPLAYTIME_TOOLTIP = '';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_DISPLAYTIME_TOOLTIP = '';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_INIT = 'TM1637 Init';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_BRIGHTNESS = 'TM1637 Bright';
|
||
En.MIXLY_4DIGITDISPLAY_4DIGITDISPLAY_BRIGHTNESS_TOOLTIP = '';
|
||
En.MIXLY_4DIGITDISPLAY_TM1637_CLEARDISPLAY = 'TM1637 clear screen';
|
||
En.MIXLY_YEAR = 'year';
|
||
En.MIXLY_MONTH = 'month';
|
||
En.MIXLY_DAY = 'day';
|
||
En.MIXLY_HOUR = 'Hour';
|
||
En.MIXLY_MINUTE = 'minute';
|
||
En.MIXLY_SECOND = 'second';
|
||
En.MIXLY_WEEK = 'week';
|
||
En.MIXLY_WEEK2 = 'Week';
|
||
En.MIXLY_MILLISECOND = 'ms';
|
||
En.MIXLY_DS1302_INITPIN = 'DS1302 Init Pin';
|
||
En.MIXLY_SETDATE = 'Set Date:';
|
||
En.MIXLY_DATEFORMATE = 'Date Format(y-m-d)';
|
||
En.MIXLY_TIMEFORMATE = 'Time Formate(H:M:S)';
|
||
En.MIXLY_DISPLAY_MATRIX_INIT = "HT16K33 Matrix Init";
|
||
En.MIXLY_DISPLAY_MATRIX_SHOW = "Dot matrix display";
|
||
En.MIXLY_DISPLAY_MATRIX_X = 'X Axis';
|
||
En.MIXLY_DISPLAY_MATRIX_Y = 'Y Axis';
|
||
En.MIXLY_DISPLAY_MATRIX_SHOWPOINT = ' Single point set to';
|
||
En.MIXLY_DISPLAY_MATRIX_SHOWPOINT_TOOLTIP = 'Single point operation on the dot matrix screen, XY axis value range 1-8';
|
||
En.MIXLY_DISPLAY_MATRIX_CLEAR = " Dot matrix clear";
|
||
En.MIXLY_DISPLAY_MATRIX_ARRAYVAR = "Array variable";
|
||
En.MIXLY_DISPLAY_MATRIX_PICARRAY = " Pictur Array";
|
||
En.MIXLY_DISPLAY_MATRIX_ROTATE = "Rotate screen";
|
||
En.MIXLY_RTCINIT = 'Initialize RTC clock module';
|
||
En.MIXLY_RTCGETTIME = 'Get Time';
|
||
En.MIXLY_RTCSETTIME = 'Set time';
|
||
En.MIXLY_RTCSETDATE = 'Set date ';
|
||
En.MIXLY_GET = 'get';
|
||
En.MIXLY_SYSTEM = 'system';
|
||
En.MIXLY_ADXL345 = 'Acceleration sensor ADXL345';
|
||
En.MIXLY_ADXL345_XA = 'X-axis angle';
|
||
En.MIXLY_ADXL345_YA = 'Y-axis angle';
|
||
En.MIXLY_ADXL345_ZA = 'Z-axis angle';
|
||
En.MIXLY_ADXL345_XA = 'X-axis angle';
|
||
En.MIXLY_ADXL345_YA = 'Y-axis angle';
|
||
En.MIXLY_ADXL345_ZA = 'Z-axis angle';
|
||
En.MIXLY_Accel_X = 'X-Accel';
|
||
En.MIXLY_Accel_Y = 'Y-Accel';
|
||
En.MIXLY_Accel_Z = 'Z-Accel';
|
||
En.MIXLY_Gyro_X = 'X-Gyro';
|
||
En.MIXLY_Gyro_Y = 'Y-Gyro';
|
||
En.MIXLY_Gyro_Z = 'Z-Gyro';
|
||
En.MixGo_MPU9250_AX = 'X-Accel';
|
||
En.MixGo_MPU9250_AY = 'Y-Accel';
|
||
En.MixGo_MPU9250_AZ = 'Z-Accel';
|
||
En.MixGo_MPU9250_GX = 'x-Gyro';
|
||
En.MixGo_MPU9250_GY = 'y-Gyro';
|
||
En.MixGo_MPU9250_GZ = 'z-Gyro';
|
||
En.MixGo_MPU9250_MX = 'x-Magnet';
|
||
En.MixGo_MPU9250_MY = 'y-Magnet';
|
||
En.MixGo_MPU9250_MZ = 'z-Magnet';
|
||
En.MIXLY_MICROBIT_JS_IS_GESTURE = 'Is gesture ';
|
||
En.MIXLY_MICROBIT_JS_SERIAL_WHEN_CONTAIN_DATA = 'When Serial recevied data containing ';
|
||
En.MIXLY_MICROBIT_JS_SERIAL_READ_LINE = 'Serial read one line';
|
||
En.MIXLY_MICROBIT_JS_RANDOM_BOOLEAN = 'Random true or false';
|
||
En.MIXLY_MICROBIT_JS_PERIOD = 'set period(us)';
|
||
En.MIXLY_MICROBIT_JS_PERIOD_MIL = 'The period (milliseconds) is set to';
|
||
En.MIXLY_MICROBIT_JS_PULSE_STATUS = 'pulse mode';
|
||
En.MIXLY_MICROBIT_JS_RADIO_SEND_NUMBER = 'radio send number';
|
||
En.MIXLY_MICROBIT_JS_RADIO_SEND_VALUE = 'radio send value';
|
||
En.MIXLY_MICROBIT_JS_RADIO_SEND_STRING = 'radio send string';
|
||
En.MIXLY_MICROBIT_JS_RADIO_ON_RECEIVE = 'on radio received';
|
||
En.MIXLY_MICROBIT_JS_RADIO_SET_GROUP = 'radio set group';
|
||
En.MIXLY_MICROBIT_JS_RADIO_SET_TRANSMIT_POWER = 'radio set transmit power';
|
||
En.MIXLY_MICROBIT_JS_RADIO_SET_TRANSMIT_SERIAL_NUMBER = 'radio set transmit serial number';
|
||
En.MIXLY_MICROBIT_JS_RADIO_WRITE_RECEIVE_PACKET_TO_SERIAL = 'radio write received packet to serial';
|
||
En.MIXLY_MICROBIT_JS_CREATE_SPRITE = 'create sprite at x:';
|
||
En.MIXLY_MICROBIT_JS_Y = 'y:';
|
||
En.MIXLY_MICROBIT_JS_MOVE_BY = 'move by';
|
||
En.MIXLY_MICROBIT_JS_DELETE_VAR = 'delete';
|
||
En.MIXLY_MICROBIT_JS_TURN = 'turn';
|
||
En.MIXLY_MICROBIT_JS_BY_ANGLE = ' by ANGLE';
|
||
En.MIXLY_MICROBIT_JS_NUMBER = 'by';
|
||
En.MIXLY_MICROBIT_JS_TOUCH = 'touch';
|
||
En.MIXLY_MICROBIT_JS_TOUCH_EDGE = 'touch edge?';
|
||
En.MIXLY_MICROBIT_JS_CHANGE_SCORE = 'change score by';
|
||
En.MIXLY_MICROBIT_JS_SET_SCORE = 'set score';
|
||
En.MIXLY_MICROBIT_JS_ON_EDGE_BOUNCE = 'if on edge, bounce'
|
||
En.MIXLY_MICROBIT_JS_START_COUNTDOWN = 'start countdown(ms)';
|
||
En.MIXLY_MICROBIT_JS_SCORE = 'game score';
|
||
En.MIXLY_MICROBIT_JS_GAME_OVER = 'game over';
|
||
En.MIXLY_MICROBIT_JS_GAME_RESUME = 'game resume';
|
||
En.MIXLY_MICROBIT_JS_GAME_PAUSE = 'game pause';
|
||
En.MIXLY_MICROBIT_JS_ACCELERATION = 'Return acceleration (mg)';
|
||
En.MIXLY_MICROBIT_JS_SET_ACCELERATION = 'set acceleration range';
|
||
En.MIXLY_MICROBIT_JS_LIGHT_LEVEL = 'light level';
|
||
En.MIXLY_MICROBIT_JS_CALIBRATE_COMPASS = 'calibrate compass';
|
||
En.MIXLY_MICROBIT_JS_GET_COMPASS = 'get compass';
|
||
En.MIXLY_MICROBIT_JS_ROTATION = 'rotation(angle)';
|
||
En.MIXLY_MICROBIT_JS_MAGETIC_FORCE = 'magnetic force(uT)';
|
||
En.MIXLY_MICROBIT_JS_BEAT = 'beats';
|
||
En.MIXLY_MICROBIT_JS_RING_TONE = 'ring tone (Hz)';
|
||
En.MIXLY_MICROBIT_JS_REST_TONE = 'rest(ms)';
|
||
En.MIXLY_MICROBIT_JS_START_MELODY = 'start melody';
|
||
En.MIXLY_MICROBIT_JS_MUSIC_EVENT = 'music on';
|
||
En.MIXLY_MICROBIT_JS_GET_TEMPO = 'tempo (bpm)';
|
||
En.MIXLY_MICROBIT_JS_CHANGE_TEMPO = 'change tempo by (bpm)';
|
||
En.MIXLY_MICROBIT_JS_SET_TEMPO = 'set tempo to (bpm)';
|
||
En.MIXLY_MICROBIT_JS_I2C_READ_ADDRESS = 'i2c read number at address';
|
||
En.MIXLY_MICROBIT_JS_I2C_FORMAT = 'of format';
|
||
En.MIXLY_MICROBIT_JS_I2C_WRITE_ADDRESS = 'i2c write number at address';
|
||
En.MIXLY_MICROBIT_JS_I2C_VALUE = 'of value';
|
||
En.MIXLY_MICROBIT_JS_I2C_SETUP = 'i2c init';
|
||
En.MIXLY_MICROBIT_JS_SPI_WRITE = 'spi write';
|
||
En.MIXLY_MICROBIT_JS_SPI_FREQUENCY = 'spi frequency';
|
||
En.MIXLY_MICROBIT_JS_SPI_FORMAT = 'spi format';
|
||
En.MIXLY_MICROBIT_JS_SPI_SET_PINS = 'spi set pins';
|
||
En.MIXLY_MICROBIT_JS_BLE_SERVICE = 'bluetooth service';
|
||
En.MIXLY_MICROBIT_JS_BLE_ON_CONNECTED = 'on bluetooth connected';
|
||
En.MIXLY_MICROBIT_JS_BLE_ON_DISCONNECTED = 'on bluetooth disconnected';
|
||
En.MIXLY_MICROBIT_JS_BLE_ON_RECEIVE = 'bluetooth on data received';
|
||
En.MIXLY_MICROBIT_JS_BLE_CONNECTED = 'connectable';
|
||
En.MIXLY_MICROBIT_JS_BLE_NAMESPACE = 'namespace(bytes 6-9)';
|
||
En.MIXLY_MICROBIT_JS_BLE_INSTANCE = 'instance(bytes 2-6)';
|
||
En.MIXLY_MICROBIT_JS_BLE_POWER = 'power';
|
||
En.MIXLY_MICROBIT_JS_BLE_URL = 'url'
|
||
En.MIXLY_MICROBIT_JS_BLE_WRITE_NUMBER = 'bluetooth uart write number';
|
||
En.MIXLY_MICROBIT_JS_BLE_WRITE_STRING = 'bluetooth uart write string';
|
||
En.MIXLY_MICROBIT_JS_BLE_WRITE_VALUE = 'bluetooth uart write value';
|
||
En.MIXLY_MICROBIT_JS_BLE_UART_SERVICE = 'bluetooth uart service';
|
||
En.MIXLY_MICROBIT_JS_BLE_STOP_ADVERTISING = 'bluetooth stop advertising';
|
||
En.MIXLY_MICROBIT_JS_BLE_SET_POWER = 'bluetooth set transmit power';
|
||
En.MIXLY_MICROBIT_JS_BLE_READ_UNTIL = 'bluetooth uart read until';
|
||
En.MIXLY_MICROBIT_JS_BLE_URL_CONNECTED = 'bluetooth advertise url. connectable';
|
||
En.MIXLY_MICROBIT_JS_BLE_UID_CONNECTED = 'bluetooth advertise UID. connectable';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_RUN_BACKGROUND = 'run in background';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_WAIT = 'wait (us)';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_RAISE_SOURCE = 'raise event from source';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_RAISE_VALUE = 'with value';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_ON_SOURCE = 'on event from source';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_TIMESTAMP = 'event timestamp';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_VALUE = 'event value';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_DEVICE_NAME = 'device name';
|
||
En.MIXLY_MICROBIT_JS_SYSTEM_DEVICE_SERIAL_NUMBER = 'device serial number';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SHOW_NUMBER = 'show number';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SHOW_IMAGE_OR_STRING = 'show image/string';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SHOW_STRING_ONE_BY_ONE = 'show';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SHOW_LEDS = 'show leds';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SHOW_ARROW = 'show arrow';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_PLOT_POINT_X = 'plot x';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_PLOT_POINT_Y = 'y';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_UNPLOT_POINT_X = 'unplot x';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_TOGGLE_POINT_X = 'toggle x';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_GET_POINT_X = 'point x';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_PLOT_BAR_START = 'plot bar graph of';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_PLOT_BAR_END = 'up to';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SET_BRIGHTNESS = 'set brightness';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_STOP_ANIMATION = 'stop animation';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_LED_ENABLE = 'led enable';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SHOW_IMAGE = 'show image';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_AT_OFFSET = 'at offset';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_CREATE_IMAGE = 'create image';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SCROLL_IMAGE = 'scroll image';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_WITH_OFFSET = 'with offset';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SCROLL_INTERVAL = 'and interval(ms)';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_CREATE_BIG_IMAGE = 'create big image';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_ARROW_IMAGE = 'arrow image';
|
||
En.MIXLY_MICROBIT_JS_TYPE_ARRAY_NUMBER = 'Array<number>';
|
||
En.MIXLY_MICROBIT_JS_TYPE_ARRAY_STRING = 'Array<string>';
|
||
En.MIXLY_MICROBIT_JS_LIST_ADD_VALUE = 'add value';
|
||
En.MIXLY_MICROBIT_JS_LIST_TO_END = 'to end';
|
||
En.MIXLY_MICROBIT_JS_LIST_GET_AND_REMOVE_LAST = 'get and remove last value from ';
|
||
En.MIXLY_MICROBIT_JS_LIST_INSERT_AT = 'insert at';
|
||
En.MIXLY_MICROBIT_JS_LIST_VALUE = 'value';
|
||
En.MIXLY_MICROBIT_JS_LIST_REVERSE = 'reverse';
|
||
En.MIXLY_MICROBIT_JS_LIST_CLEAR = 'clear';
|
||
En.MIXLY_MICROBIT_JS_LIST_GET_AND_REMOVE_FIRST = 'get and remove first value from';
|
||
En.MIXLY_MICROBIT_JS_LIST_INSERT = 'insert';
|
||
En.MIXLY_MICROBIT_JS_LIST_AT_BEGINNING = 'at beginning';
|
||
En.MIXLY_MICROBIT_JS_LIST_FIND_INDEX_OF = 'find index of';
|
||
En.MIXLY_MICROBIT_JS_LIST_REMOVE_VALUE_AT = 'remove value at';
|
||
En.MIXLY_MICROBIT_JS_LIST_REMOVE_VALUE_XIANG = '';
|
||
En.MIXLY_MICROBIT_JS_INTERRUPT_BTN = 'Interrupt Button#';
|
||
En.MIXLY_MICROBIT_JS_INOUT_ANALOG_PITCH = 'analog pitch ';
|
||
En.MIXLY_MICROBIT_JS_INOUT_FREQUENCY = 'for (ms)';
|
||
En.INOUT_ANALOGPITCH = "analog pitch for some time";
|
||
En.MIXLY_MICROBIT_JS_INOUT_SETPIN = "set pin#";
|
||
En.MIXLY_MICROBIT_JS_INOUT_EMITEVENTS = "to emit";
|
||
En.MIXLY_MICROBIT_JS_INOUT_EVENT_EDGE = "edge";
|
||
En.MIXLY_MICROBIT_JS_INOUT_EVENT_PULSE = "pulse";
|
||
En.MIXLY_MICROBIT_JS_INOUT_EVENT_TOUCH = "touch";
|
||
En.MIXLY_MICROBIT_JS_INOUT_SETPULL = "to";
|
||
En.INOUT_SETEVENT = "configure the emit event by the pin";
|
||
En.MIXLY_MICROBIT_JS_INOUT_PULL_UP = "pull";
|
||
En.MIXLY_MICROBIT_JS_INOUT_PULL_DOWN = "down";
|
||
En.MIXLY_MICROBIT_JS_INOUT_PULL_NONE = "none";
|
||
En.INOUT_SETPULL = "configure the pull of the pin";
|
||
En.MIXLY_MICROBIT_JS_INOUT_SET_PITCH_PIN = "analog set pitch pin#";
|
||
En.INOUT_SET_PITCH_PIN = "set the analog pitch pin";
|
||
En.MIXLY_MICROBIT_shake = 'shake';
|
||
En.MIXLY_MICROBIT_face_up = 'face up';
|
||
En.MIXLY_MICROBIT_face_down = 'face down';
|
||
En.MIXLY_MICROBIT_freefall = 'freefall';
|
||
En.MIXLY_MICROBIT_Accelerometer_X = 'acceleration(Dimension.X)';
|
||
En.MIXLY_MICROBIT_Accelerometer_Y = 'acceleration(Dimension.Y)';
|
||
En.MIXLY_MICROBIT_Accelerometer_Z = 'acceleration(Dimension.Z)';
|
||
En.MIXLY_MICROBIT_Was_gesture = 'was gesture %1';
|
||
En.MIXLY_MICROBIT_Is_gesture = 'is gesture %1';
|
||
En.MIXLY_MICROBIT_Get_gestures = 'get gestures';
|
||
En.MIXLY_MICROBIT_Current_gesture = 'current gesture';
|
||
En.MIXLY_MICROBIT_Button_is_pressed = 'button %1 is pressed';
|
||
En.MIXLY_MICROBIT_Button_was_pressed = 'button %1 was pressed';
|
||
En.MIXLY_MICROBIT_Get_number_of_presses_for_button = 'get number of presses for button %1 ';
|
||
En.MIXLY_MICROBIT_Calibrate_compass = 'calibrate compass';
|
||
En.MIXLY_MICROBIT_Compass_heading = 'compass heading';
|
||
En.MIXLY_MICROBIT_Get_brightness_at = 'get brightness X %1 Y %2';
|
||
En.MIXLY_MICROBIT_Set_brightness_at = 'set X %1 Y %2 brightness %3';
|
||
En.MIXLY_MICROBIT_Clear_display = 'clear display';
|
||
En.MIXLY_MICROBIT_SHOW_IMAGE_OR_STRING = 'show (image/string)';
|
||
En.MIXLY_MICROBIT_Animate_images_or_string = 'animate image/string %1 delay %2 (ms) %3 wait for %4 %5 repeating %6 %7 clear %8';
|
||
En.MIXLY_MICROBIT_Scroll_message = 'scroll message %1';
|
||
En.MIXLY_MICROBIT_Turn_on_display = 'turn on diaplay';
|
||
En.MIXLY_MICROBIT_Turn_off_display = 'turn off display';
|
||
En.MIXLY_MICROBIT_monitor = "Display";
|
||
En.MIXLY_MICROBIT_Display_is_on = 'Display is on？';
|
||
En.MIXLY_MICROBIT_Built_in_image = 'built-in image %1';
|
||
En.MIXLY_MICROBIT_Copy_image = 'copy image %1';
|
||
En.MIXLY_MICROBIT_Invert_image = 'invert image %1';
|
||
En.MIXLY_MICROBIT_Create_image = 'create image %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17 %18 %19 %20 %21 %22 %23 %24 %25 %26 %27 %28 %29 %30';
|
||
En.MIXLY_MICROBIT_Panic_with_status_code = 'Panic with status code %1';
|
||
En.MIXLY_MICROBIT_Sleep = 'sleep %1 (ms)';
|
||
En.MIXLY_MICROBIT_Running_time = 'running time';
|
||
En.MIXLY_MICROBIT_Board_temperature = 'board temperature';
|
||
En.MIXLY_MICROBIT_Reset_micro = 'reset micro:bit';
|
||
En.MIXLY_MICROBIT_Play_built_in_melody = 'play built-in melody %1 pin #%2 %3 wait for %4 %5 repeating %6';
|
||
En.MIXLY_MICROBIT_Play_built_in_melody_easy = 'play built-in melody %1 pin #%2 %3';
|
||
En.MIXLY_MICROBIT_Play_pitch = 'play pitch %1 %2 for %3 ms';
|
||
En.MIXLY_MICROBIT_Play_notes = 'play tone %1 pin #%2 wait for %3 %4 repeating %5';
|
||
En.MIXLY_MICROBIT_Reset_music = 'reset music';
|
||
En.MIXLY_MICROBIT_Stop_music = 'stop music';
|
||
En.MIXLY_MICROBIT_Set_tempo = 'set tempo: 1 beat %1 ticks at %2 bpm';
|
||
En.MIXLY_MICROBIT_Get_current_tempo = 'get current tempo';
|
||
En.MIXLY_MICROBIT_Initialise_pin = 'initialise pin %1 with %2 neopixel[s] %3';
|
||
En.MIXLY_MICROBIT_Clear_neopixels = 'clear neopixels on %1';
|
||
En.MIXLY_MICROBIT_Show_neopixels = 'show neopixels on %1';
|
||
En.MIXLY_MICROBIT_Using_neopixels = 'using neopixels on %1 set pixel in position %2 with red %3 green %4 blue %5';
|
||
En.MIXLY_MICROBIT_Switch_on_radio = 'switch on radio';
|
||
En.MIXLY_MICROBIT_Switch_off_radio = 'switch off radio';
|
||
En.MIXLY_MICROBIT_Configure_radio = 'configure radio length %1 queue %2 %3 channel %4 %5 power %6 %7 address %8 %9 group %10 %11 data rate %12 %13';
|
||
En.MIXLY_MICROBIT_SPI_INIT = 'spi initialize (baud rate) %1 bits %2 %3 mode %4 %5 MOSI# %6 %7 MISO# %8 SCK# %9';
|
||
En.MIXLY_MICROBIT_Reset_radio = 'reset radio';
|
||
En.MIXLY_MICROBIT_Send_message = 'send message %1';
|
||
En.MIXLY_MICROBIT_Receive_message = 'receive message';
|
||
En.MIXLY_MICROBIT_Say = 'say %1';
|
||
En.MIXLY_MICROBIT_Pronounce = 'Pronounce %1';
|
||
En.MIXLY_MICROBIT_Sing = 'sing %1';
|
||
En.MIXLY_MICROBIT_Pin_touched = 'pin# %1 touched？';
|
||
En.MIXLY_MICROBIT_Read_analog = 'analog read pin# %1';
|
||
En.MIXLY_MICROBIT_Write_analog = 'analog write pin# %2 to %1';
|
||
En.MIXLY_MICROBIT_Read_digital = 'digital read pin# %1';
|
||
En.MIXLY_MICROBIT_Write_digital = 'digital write pin# %2 to %1';
|
||
En.MIXLY_MICROBIT_JS_WAS_GESTURE = 'on ';
|
||
En.MIXLY_MICROBIT_JS_GET = 'get';
|
||
En.MIXLY_MICROBIT_JS_GET_GESTURE = 'get gesture';
|
||
En.MIXLY_MICROBIT_JS_CURRENT_GESTURE = 'current gesture';
|
||
En.MIXLY_MICROBIT_JS_GESTURE = 'gesture';
|
||
En.MIXLY_MICROBIT_JS_FIELD_STRENGTH = 'field strength';
|
||
En.MIXLY_MICROBIT_JS_FIELD_STRENGTH_ALL = 'synthetical strength';
|
||
En.MIXLY_MICROBIT_JS_IS_COMPASS_CALIBRATED = 'is compass calibrated';
|
||
En.MIXLY_IS_TOUCHED = 'is touched';
|
||
En.MIXLY_WAS_PRESSED = 'was pressed';
|
||
En.MIXLY_GET_PRESSES = 'get frequency of being pressed';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SCROLL_STRING = 'scroll string';
|
||
En.MIXLY_MICROBIT_PY_ACTUATOR_SPEECH_SAY = 'speak'
|
||
En.MIXLY_MICROBIT_PY_ACTUATOR_SPEECH_SING = 'sing'
|
||
En.MIXLY_MICROBIT_PY_ACTUATOR_SPEECH_PRENOUNCE = 'read'
|
||
En.LISTS_NAME_TOOLTIP = 'input list name';
|
||
En.blockpy_LIST_ADD_LIST = 'add list';
|
||
En.blockpy_LISTS_CREATE_WITH_INPUT_WITH = 'initialize list as';
|
||
En.MIXLY_blockpy_TOOLTIP_LISTS_CREATE_WITH_TEXT = 'creates a list through a string. ';
|
||
En.blockpy_MIXLY_SPLITBYDOU = 'create list';
|
||
En.blockpy_LISTS_LENGTH_TOOLTIP = "return the length of the list.";
|
||
En.blockpy_LANG_LISTS_GET_INDEX_TOOLTIP = 'return the value of the specified location in the list. ';
|
||
En.blockpy_LANG_LISTS_SET_INDEX_TOOLTIP = 'set the value of the location specified in the list. ';
|
||
En.LISTS_GET_INDEX_RANDOM2 = "random fetch list";
|
||
En.LISTS_GET_INDEX_RANDOM3 = "one of";
|
||
En.MATH_ZHENGCHU_SYMBOL = "//";
|
||
En.MIXLY_MICROBIT_JS_PERIOD_MIL = 'The period (milliseconds) is set to';
|
||
En.MIXLY_TOOLTIP_INOUT_ANALOG_WRITE_PY = 'Sets the value of the specified pin(0~1023)';
|
||
En.LISTS_ISEMPTY_TITLE = 'Is it empty?';
|
||
En.LISTS_SORT_TITLE = 'List sort %1 %2 %3';
|
||
En.LISTS_SORT_TYPE_NUMERIC = 'By number';
|
||
En.LISTS_SORT_TYPE_TEXT = 'Alphabetical';
|
||
En.LISTS_SORT_TYPE_IGNORECASE = 'By letter (ignored)';
|
||
En.LISTS_SORT_ORDER_ASCENDING = 'Ascending';
|
||
En.LISTS_SORT_ORDER_DESCENDING = 'Descending';
|
||
En.DISPLAY_IMAGE_LET = 'image';
|
||
En.DISPLAY_IMAGE_LET2 = 'towards';
|
||
En.DISPLAY_IMAGE_SHIFT = 'translation';
|
||
En.DISPLAY_IMAGE_UNIT = 'unit';
|
||
En.LANG_MATH_RANDOM_FLOAT_INPUT_FROM = 'Random decimal';
|
||
En.LANG_MATH_RANDOM_FLOAT_INPUT_TO = 'reach';
|
||
En.LANG_MATH_RANDOM_FLOAT_TOOLTIP2 = 'A random number that returns between two numbers (containing)';
|
||
En.MICROBIT_SPEECH_pitch = 'pitch';
|
||
En.MICROBIT_SPEECH_mouth = 'Mouth';
|
||
En.MICROBIT_SPEECH_throat = 'throat';
|
||
En.MICROBIT_SPEECH_translation = 'Translation to phonetics';
|
||
En.MICROBIT_ACTUATOR_ticks = 'ticks';
|
||
En.MICROBIT_PYTHON_TYPE = 'get type';
|
||
En.MICROBIT_LOGIC_IS_IN = 'is in';
|
||
En.CONTROLS_FOREACH_INPUT = "for each";
|
||
En.MICROBIT_DISPLAY_UNION = 'union';
|
||
En.MICROBIT_DISPLAY_INTERSECTION = 'intersection';
|
||
En.MICROBIT_DISPLAY_MINUS = 'minus';
|
||
En.MICROBIT_DISPLAY_MERGE_SHAPE = 'merge shape';
|
||
En.DICTS_CREATE_EMPTY_TITLE = "initialization to an empty dictionary";
|
||
En.DICTS_CREATE_EMPTY_TOOLTIP = "return an empty dictionary with a length of 0 and does not contain any data";
|
||
En.DICTS_CREATE_WITH_CONTAINER_TOOLTIP = "Add, delete, or rearrange parts to reconfigure the dictionary block.";
|
||
En.DICTS_CREATE_WITH_INPUT_WITH = "initialize dictionary as";
|
||
En.DICTS_CREATE_WITH_ITEM_TITLE = "item"
|
||
En.DICTS_CREATE_WITH_ITEM_TOOLTIP = "Add an item to the dictionary.";
|
||
En.DICTS_CREATE_WITH_TOOLTIP = "Create a dictionary with any number of items.";
|
||
En.DICTS_CREATE_WITH_ITEM_KEY = "key"
|
||
En.DICT_KEYS = "get all key values";
|
||
En.DICTS_KEYS_TOOLTIP = "Return a list, including all the keys of a dictionary.";
|
||
En.DICTS_GET_FROM_DICTS = "from the dictionary";
|
||
En.DICTS_GET_IN = "get key values";
|
||
En.DICTS_GET_TOOLTIP = "Gets the corresponding value of a key in the dictionary. If the key name does not exist, keyerror will be triggered";
|
||
En.DICTS_GET_DEFAULT_TOOLTIP = "Gets the corresponding value of a key in the dictionary. If the key name does not exist, it returns the default value";
|
||
En.DICTS_ADD_in_DICT = "in dictionary";
|
||
En.DICTS_ADD = "add or modify a clause, key value";
|
||
En.DICTS_ADD_VALUE = "corresponding value";
|
||
En.DICTS_ADD_VALUE = "corresponding value";
|
||
En.DICTS_DELETE_IN = "delete clause, key value";
|
||
En.DICTS_DELETE_VALUE = "and corresponding value";
|
||
En.DICTS_DELETE_TOOLTIP = "Delete a clause in the dictionary";
|
||
En.DICT_CLEAR = "clear dictionary";
|
||
En.DICT_ITEMS = "transform dictionary to a list";
|
||
En.DICTS_ITEMS_TOOLTIP = "Return a list, including all the keys and corresponding values that a dictionary can be traversed";
|
||
En.DICT_VALUES = "get the values corresponding to all keys";
|
||
En.DICTS_VALUES_TOOLTIP = "Return a list, including the corresponding values of all the keys in a dictionary";
|
||
En.DICTS_LENGTH_TOOLTIP = "Return the length of the dictionary, the number of the keys";
|
||
En.DICT_DELDICT = "delete dictionary";
|
||
En.OBJECT_DELETE = "delete list/tuple/dict/set";
|
||
En.MATH_BIN = 'binary';
|
||
En.MATH_DEC = 'decimal';
|
||
En.MATH_OCT = 'octal';
|
||
En.MATH_HEX = 'hex';
|
||
En.MIXLY_MICROBIT_TYPE_FLOAT = 'float';
|
||
En.MIXLY_MICROBIT_TYPE_STRING = "string";
|
||
En.MIXLY_MICROBIT_TYPE_LIST = "list";
|
||
En.MIXLY_MICROBIT_TYPE_TUPLE = "tuple";
|
||
En.MIXLY_MICROBIT_TYPE_DICT = "dictionary";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_OPEN_FILE = "open file";
|
||
En.MIXPY_PANDAS_READ_CSV = "Read CSV file;";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_MODE = "mode";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_READ = "read"
|
||
En.MIXLY_MICROBIT_PY_STORAGE_WRITE = "write"
|
||
En.MIXLY_MICROBIT_PY_STORAGE_BIT_READ = "bit read";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_BIT_WRITE = "bit write";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_AS = "as";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FILE_WRITE = "write in file";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FROM_FILE = 'from file';
|
||
En.MIXLY_MICROBIT_PY_STORAGE_NO_MORE_THAN_SIZE = "read content, no more than";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_ONE_LINE_NO_MORE_THAN_SIZE = "read in a line, no more than"
|
||
En.MIXLY_MICROBIT_PY_STORAGE_ALL_LINES_NO_MORE_THAN_SIZE = "Read All Lines,no more than";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_CHARACTER = "character";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_CAN_WRITE_ORNOT = "writable or not";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_GET = "get";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FILENAME = "filename";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_CLOSE_FILE = "close file";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_LIST_ALL_FILES = "list all files";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_DELETE_FILE = "delete file";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_GET_FILE_SIZE = "get fill";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_SIZE = "size";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_RETURN_FILE = "Return file";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_PRESENT_LOCATION = "Current read position";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FILE_TELL = "Return the current position";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_SET_FILE_POSITION = "Setting file";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_CURRENT_POSITION = "Current Position";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FILE_SEEK_START = "From the beginning of the file";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FILE_SEEK_CURRENT = "From the current position";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FILE_SEEK_END = "From the end of the file";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_FILE_SEEK_OFFSET = "offset";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_CHANGE_DIR = 'change Dir';
|
||
En.MIXLY_MICROBIT_PY_STORAGE_GET_CURRENT_DIR = "Get current dir";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_MKDIR = "folder";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_MAKEDIRS = "Nested folder";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_PATH = "According to the catalog";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_DELETE_DIRS = "Delete Dir";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_RENAME = "Rename";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_TO = "To";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_IS_OR_NOT = "yes OR no";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_IS_DIR = "Dir";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_THE_PATH = "path";
|
||
En.MIXLY_MICROBIT_PY_CONTORL_GET_TYPE = "data type";
|
||
En.MIXLY_MICROBIT_PY_CONTORL_UNAME = "current system information";
|
||
En.MIXLY_MICROBIT_SHOW_STRING = " %1 delay %2 millisecond %3 wait %4 %5 loop %6 %7 clear %8";
|
||
En.MIXLY_COMMUNICATION_RFID_INITIAL = "initialize RFID as";
|
||
En.MIXLY_COMMUNICATION_RFID_ON_DETECTED = "on signal detected";
|
||
En.MIXLY_COMMUNICATION_RFID_READ_CARDNUM = "card number read by RFID";
|
||
En.MIXLY_COMMUNICATION_RFID_READ_CARDNUM_IS = "card numbers detected by RFID is";
|
||
En.MIXLY_COMMUNICATION_RFID_WRITE = "RFID write card";
|
||
En.MIXLY_COMMUNICATION_DATA_BLOCK = "data block";
|
||
En.MIXLY_COMMUNICATION_WRITE_NUM = "write data";
|
||
En.MIXLY_MICROBIT_PY_COMMUNICATE_WIFI = "wireless";
|
||
En.MIXLY_MICROBIT_PY_COMMUNICATE_ON = "on";
|
||
En.MIXLY_MICROBIT_PY_COMMUNICATE_OFF = "off";
|
||
En.MIXLY_COMMUNICATION_RFID_TOOLTIP = "This is RFID's reading card";
|
||
En.MIXLY_COMMUNICATION_RFID_READ = "RFID read";
|
||
En.MIXLY_COMMUNICATION_DATA_FROM = "data from";
|
||
En.MIXLY_COMMUNICATION_RFID_OFF = "RFID stop detection";
|
||
En.HTML_RESET = "reset";
|
||
En.blockpy_inout_input = 'Receive input';
|
||
En.blockpy_inout_raw_input = 'Receive string input';
|
||
En.INOUT_input_TOOLTIP = 'Receive keyboard input, end of carriage return, prompt prompt is provided to the user';
|
||
En.INOUT_raw_input_TOOLTIP = 'Receive keyboard input in string format, end of carriage return, prompt is input prompt for user';
|
||
En.blockpy_turtle_create = 'Create Tortoise';
|
||
En.blockpy_turtle_create_TOOLTIP = 'Create a new turtle';
|
||
En.blockpy_forward = 'Forward';
|
||
En.blockpy_backward = 'Backward';
|
||
En.blockpy_turtle_move_num = 'steps';
|
||
En.MIXLY_TOOLTIP_TURTEL_FORWARD = 'Command Turtle Moves Forward';
|
||
En.MIXLY_TOOLTIP_TURTEL_BACKWARD = 'Command turtle to move backwards';
|
||
En.blockpy_left = 'Left';
|
||
En.blockpy_right = 'Right';
|
||
En.blockpy_turtle_rotate = 'rotate';
|
||
En.MIXLY_TOOLTIP_TURTEL_LEFT = 'Command Tortoise Rotates Left';
|
||
En.MIXLY_TOOLTIP_TURTEL_RIGHT = 'Command Tortoise Rotates Right';
|
||
En.blockpy_setheading = 'Orientation';
|
||
En.blockpy_setheading_degree = 'degree';
|
||
En.blockpy_time_time = 'Time stamp of the current time';
|
||
En.blockpy_SET_CREATE_WITH_TOOLTIP = "Build a set with any number of elements.";
|
||
En.blockpy_SET_CREATE_EMPTY_TITLE = "Initialize to empty set";
|
||
En.blockpy_SET_CREATE_WITH_INPUT_WITH = 'initialize set is';
|
||
En.blockpy_SET_CREATE_WITH_CONTAINER_TITLE_ADD = "set";
|
||
En.blockpy_SET_CREATE_WITH_CONTAINER_TOOLTIP = "Add, delete, or rearrange parts to reconfigure this set block.";
|
||
En.blockpy_SET_VARIABLES_NAME = "Elements";
|
||
En.blockpy_SET_CREATE_WITH_ITEM_TOOLTIP = "Add an element to the set.";
|
||
En.SET_LENGTH_TOOLTIP = "return the number of elements in the set.";
|
||
En.SET_CLEAR = "Empty all elements in the set";
|
||
En.LISTS_TO_SET = "convert to set";
|
||
En.blockpy_USE_LIST = 'will list';
|
||
En.LISTS_TO_SET_TOOLTIP = "Create a set from a list";
|
||
En.blockpy_set_union = 'consolidation';
|
||
En.blockpy_set_intersection = 'Intersection';
|
||
En.blockpy_set_difference = 'difference';
|
||
En.blockpy_set = 'set';
|
||
En.blockpy_and_set = 'and set';
|
||
En.blockpy_set_get_operate = 'Fetch';
|
||
En.MIXLY_TOOLTIP_SET_UNION = 'return the union of two sets';
|
||
En.MIXLY_TOOLTIP_SET_INTERSECTION = 'Return the intersection of two sets';
|
||
En.MIXLY_TOOLTIP_SET_DIFFERENCE = 'Returns the difference between two sets';
|
||
En.MIXLY_blockpy_set_add = 'Add';
|
||
En.SET_ADD_TOOLTIP = "Add an element to the set. If this element is already in the set, it has no effect.";
|
||
En.MIXLY_blockpy_set_discard = 'Remove';
|
||
En.SET_DISCARD_TOOLTIP = "Remove an element from the set. If this element is not in the set, it has no effect.";
|
||
En.blockpy_set_update = 'and update';
|
||
En.MIXLY_TOOLTIP_SET_UPDATE = 'take the union of two sets and assign it to the previous set';
|
||
En.MIXLY_TOOLTIP_SET_INTERSECTION_UPDATE = 'take the intersection of two sets, and assign to the previous set';
|
||
En.MIXLY_TOOLTIP_SET_DIFFERENCE_UPDATE = 'take the difference of two sets, and assign to the previous set';
|
||
En.blockpy_set_of = 's';
|
||
En.blockpy_is_set = 'is a set';
|
||
En.blockpy_set_sub = 'Subset';
|
||
En.blockpy_set_super = 'superset';
|
||
En.MIXLY_TOOLTIP_SET_SUB = 'to determine whether the previous set is a subset of the next set, return Boolean value';
|
||
En.MIXLY_TOOLTIP_SET_SUPER = 'to determine whether the previous set is a superset of the next set, return boolean';
|
||
En.blockpy_turtle_reset = 'Reset';
|
||
En.blockpy_turtle_home = 'Back to origin';
|
||
En.blockpy_turtle_drawing = 'Trail';
|
||
En.MIXLY_TOOLTIP_TURTEL_CLEAR = 'Clear all traces of the turtle, turtle position and status unchanged';
|
||
En.MIXLY_TOOLTIP_TURTEL_RESET = 'Clear all traces of the turtle, Tortoise state reset to initial state';
|
||
En.MIXLY_TOOLTIP_TURTEL_HOME = 'The turtle returned to the origin and restored to its original state, the trace remains unchanged';
|
||
En.blockpy_turtle_penup = 'Pick up';
|
||
En.blockpy_turtle_pendown = 'drop pen';
|
||
En.blockpy_turtle_blank = ' ';
|
||
En.MIXLY_TOOLTIP_TURTEL_PENUP = 'Put the pen, the turtle will not leave traces when moving';
|
||
En.MIXLY_TOOLTIP_TURTEL_PENDOWN = 'pen down, the turtle will leave a trail when moving';
|
||
En.blockpy_turtle_size = 'Thickness';
|
||
En.blockpy_turtle_set = 'Setting the brush';
|
||
En.blockpy_turtle_set_num = 'yes';
|
||
En.MIXLY_TOOLTIP_TURTEL_SIZE = 'Set the thickness of turtle traces';
|
||
En.MIXLY_TOOLTIP_TURTEL_SPEED = 'Set the turtle\'s movement speed when painting';
|
||
En.blockpy_turtle_circle = 'Circle';
|
||
En.blockpy_turtle_dot = 'point';
|
||
En.blockpy_turtle_drawing = 'Trail';
|
||
En.blockpy_turtle_radius = 'Radius';
|
||
En.MIXLY_TOOLTIP_TURTEL_CIRCLE = 'Draw a hollow circle';
|
||
En.MIXLY_TOOLTIP_TURTEL_DOT = 'Draw a Solid Dot';
|
||
En.MIXLY_TURTEL_SHAPESIZE = "set turtle icon size;";
|
||
En.MIXLY_TURTEL_SHAPESIZE_WID = "vertical stretch multiple;";
|
||
En.MIXLY_TURTEL_SHAPESIZE_LEN = 'Horizontal stretch multiple';
|
||
En.MIXLY_TURTEL_SHAPESIZE_OUTLINE = "outline width;";
|
||
En.MIXLY_TOOLTIP_SHAPESIZE = "set the size of the turtles icon. The three parameters are the stretch multiple in the vertical direction with the current arrow direction, the stretch multiple in the horizontal direction with the current arrow direction, and the contour width value;";
|
||
En.MIXLY_TURTEL_GET_SHAPESIZE = "turtle icon size;";
|
||
En.MIXLY_TURTEL_GET_SHAPESIZE_TOOLTIP = "get the current icon size of the turtle, and return a tuple with a length of 3, which respectively represents the stretch times of the turtle in the current vertical direction, the stretch times in the horizontal direction and the contour width value;";
|
||
En.MIXLY_TURTEL_GETSCREEN = 'Initialize the turtle screen';
|
||
En.MIXLY_TURTEL_GETSCREEN_TOOLTIP = 'Initialize the turtle screen, allow screen adjustments or create screen events';
|
||
En.MIXLY_TURTEL_EVENT_ONKEY = 'Create event press button';
|
||
En.MIXLY_TURTEL_EVENT_ONKEY_TOOLTIP = 'Create a keyboard response event. String key values can be ordinary keys or function keys. A key value of None means that any key press will trigger.';
|
||
En.MIXLY_TURTEL_EVENT_ONCLICK = "create event Click;";
|
||
En.MIXLY_TURTEL_EVENT_ONCLICK_TOOLTIP = "Create a mouse response event, click the left mouse button to trigger the corresponding function (this function must contain two parameters, corresponding to the horizontal and vertical coordinates of the mouse click);";
|
||
En.MIXLY_TURTEL_EVENT_ONTIMER = 'Create event countdown';
|
||
En.MIXLY_TURTEL_EVENT_ONTIMER_TOOLTIP = 'Create a countdown event that triggers the corresponding function at the specified time';
|
||
En.MIXLY_TURTEL_SCREEN_LISTEN = "event effective;";
|
||
En.blockpy_turtle_show = 'Show turtle';
|
||
En.blockpy_turtle_hide = 'Hidden Tortoise';
|
||
En.MIXLY_TOOLTIP_TURTEL_SHOW = 'Show turtles as arrows';
|
||
En.MIXLY_TOOLTIP_TURTEL_HIDE = 'Hidden arrow indicating turtle';
|
||
En.blockpy_turtle_goto = 'y';
|
||
En.blockpy_turtle_goto_y = 'y';
|
||
En.blockpy_turtle_goto_position = 'Location';
|
||
En.blockpy_turtle_setx = 'x';
|
||
En.blockpy_turtle_sety = 'y';
|
||
En.MIXLY_TOOLTIP_TURTEL_SETX = 'Turtle moves horizontally to a given coordinate position';
|
||
En.MIXLY_TOOLTIP_TURTEL_SETY = 'Turtle moves vertically to a given coordinate position';
|
||
En.blockpy_turtle_setxy_num = 'Coordinates';
|
||
En.blockpy_turtle_bgcolor = 'Set Background Color';
|
||
En.blockpy_turtle_pencolor = 'Set brush color';
|
||
En.blockpy_turtle_fillcolor = 'Set brush fill color';
|
||
En.TUPLE_CREATE_WITH_TOOLTIP = "Create a tuple with any number of items.";
|
||
En.TUPLE_CREATE_EMPTY_TITLE = "Initialize to empty tuple";
|
||
En.TUPLE_CREATE_WITH_INPUT_WITH = "initialize tuple as";
|
||
En.TUPLE_CREATE_WITH_CONTAINER_TITLE_ADD = "Tuple";
|
||
En.TUPLE_CREATE_WITH_CONTAINER_TOOLTIP = "Add, delete, or rearrange parts to reconfigure this tuple block.";
|
||
En.TUPLE_CREATE_WITH_ITEM_TOOLTIP = "Add an element to an element.";
|
||
En.TUPLE_GET_INDEX_TOOLTIP = 'Return the value of the specified position in the tuple. ';
|
||
En.TUPLE_LENGTH_TOOLTIP = "return the length of the tuple.";
|
||
En.TUPLE_DEL = "Delete tuple";
|
||
En.TUPLE_JOIN = "Connect";
|
||
En.TUPLE_JOIN_TOOLTIP = "Connect two tuples to form a new tuple.";
|
||
En.LISTS_TO_TUPLE = "Convert to tuple";
|
||
En.blockpy_TUPLE_MAX = 'Maximum';
|
||
En.blockpy_TUPLE_MIN = 'Minimum';
|
||
En.blockpy_turtle_set_size = 'Set the brush size';
|
||
En.blockpy_turtle_set_speed = 'Set the brush speed';
|
||
En.MICROPYTHON_TOOLTIP_LISTS_CREATE_WITH_TEXT = "create list from string.";
|
||
En.MIXPY_TOOLTIP_TUPLE_CREATE_WITH_TEXT = "create tuple from string.";
|
||
En.MIXPY_TOOLTIP_SET_CREATE_WITH_TEXT = "Create a the set with a string. ";
|
||
En.blockpy_MIXLY_TUPLE_CREATE = 'create tuple';
|
||
En.TURTLE_CLONE = "clone turtle";
|
||
En.TURTLE_CLONE_TOOLTIP = "clone a turtle.";
|
||
En.blockpy_turtle_angle = 'angle';
|
||
En.blockpy_turtle_beginfill = 'begin fill';
|
||
En.blockpy_turtle_endfill = 'end fill';
|
||
En.MIXLY_TOOLTIP_TURTEL_BEGINFILL = 'turtle begin fill';
|
||
En.MIXLY_TOOLTIP_TURTEL_ENDFILL = 'turtle end fill';
|
||
En.blockpy_USE_TUPLE = 'change tuple';
|
||
En.LISTS_TO_TUPLE_TOOLTIP = "Create tuples from the list";
|
||
En.BLOCKPY_PRINT_TOOLTIP = "print text or number with return.";
|
||
En.MIXLY_TOOLTIP_TUPLE_MAX = 'Get the Maximum from the tuple';
|
||
En.MIXLY_TOOLTIP_TUPLE_MIN = 'Get the Maximum from the tuple';
|
||
En.MIXLY_DE = "s";
|
||
En.MIXLY_UPDATE = 'update';
|
||
En.MIXLY_LIST_LEN = 'length';
|
||
En.MIXLY_LIST_COUNT = 'count';
|
||
En.MIXLY_LIST_INDEX = 'index';
|
||
En.A_TO_B = 'into';
|
||
En.MIXLY_MICROBIT_WAIT = 'wait';
|
||
En.MIXLY_MICROBIT_RANDOM = 'random';
|
||
En.TUPLE_TO_SET = "Convert tuples to sets";
|
||
En.TUPLE_TO_LISTS = "into list";
|
||
En.SET_TO_TUPLE = "Convert the set to a tuple";
|
||
En.SET_TO_LISTS = "Convert sets to lists";
|
||
En.MATH_BA = 'put';
|
||
En.MATH_JinZhi = "Dead";
|
||
En.MATH_ZHW = "Convert to";
|
||
En.MATH_Before_two = 'binary number converted to';
|
||
En.MATH_Before_eight = 'converted to octal number';
|
||
En.MATH_Before_ten = 'decimal number converted to';
|
||
En.MATH_Before_sixteen = 'Convert hexadecimal number to';
|
||
En.MATH_Behind_two = 'binary number';
|
||
En.MATH_Behind_eight = 'octal number';
|
||
En.MATH_Behind_ten = 'decimal number';
|
||
En.MATH_Behind_sixteen = 'hexadecimal number';
|
||
En.MIXLY_TOOLTIP_sensor_pin_pressed = 'Return pin is touched';
|
||
En.MIXLY_TOOLTIP_INOUT_ANALOG_WRITE_SET = 'Set Pin Period';
|
||
En.MICROBIT_controls_TypeLists = 'return data type';
|
||
En.IN = 'If the element (x) returns true in the sequence';
|
||
En.MATH_TWO = 'two';
|
||
En.MATH_TEN = 'Ten';
|
||
En.MATH_EIGHT = 'eight';
|
||
En.MATH_SIXTEEN = '16';
|
||
En.TEXT_GET_INDEX_RANDOM = 'random';
|
||
En._GET_TEXT_SUBLIST_TOOLTIP = "Return the specified part of the string.";
|
||
En.MIXLY_TOOLTIP_TEXT_LENGTH = 'Get string length';
|
||
En.MIXLY_SENOR_IS_PRESSED = 'The button is pressed to return true';
|
||
En.MIXLY_SENOR_WAS_PRESSED = 'Button is pressed back to true';
|
||
En.MIXLY_MICROBIT_JS_CURRENT = 'When';
|
||
En.MIXLY_MICROBIT_JS_STATE = 'Status is';
|
||
En.MIXLY_MICROBIT_PERFORMANCE = 'Execute some statements';
|
||
En.MIXLY_MICROBIT_JS_IS_COMPASS_CALIBRATED1 = 'Return true if the compass has been corrected';
|
||
En.MIXLY_MICROBIT_JS_SET_TEMPO1 = 'Set the resolution and speed of the rhythm';
|
||
En.MIXLY_MICROBIT_PY_ACTUATOR_SPEECH_SAY = 'speak'
|
||
En.MIXLY_MICROBIT_Play_notes1 = 'Playing a note list';
|
||
En.MIXLY_MICROBIT_Play_built_in_melody1 = 'Play built-in music';
|
||
En.MIXLY_MICROBIT_Copy_image1 = 'Copy Image';
|
||
En.DISPLAY_IMAGE_LET3 = 'Pan specified units';
|
||
En.MIXLY_MICROBIT_image_add = 'Merge two images';
|
||
En.MIXLY_MICROBIT_image_reduce = 'Remove image 2 from image 1';
|
||
En.MIXLY_MICROBIT_Create_image1 = 'Create Image';
|
||
En.MIXLY_MICROBIT_Invert_image1 = 'reverse display image';
|
||
En.MIXLY_MICROBIT_Display_is_on1 = 'return true if the display is already open';
|
||
En.MIXLY_MICROBIT_JS_MONITOR_SHOW_delay = 'at specified intervals';
|
||
En.MIXLY_MICROBIT_Animate_images1 = "Animated Display Image";
|
||
En.MIXLY_MICROBIT_JS_MONITOR_BRIGHTNESS1 = "Get the brightness of the point (x, y)";
|
||
En.MIXLY_MICROBIT_JS_MONITOR_BRIGHTNESS2 = "Set the brightness of the point (x, y)";
|
||
En.MIXLY_MICROBIT_Built_in_image1 = "Built-in picture";
|
||
En.MIXLY_RGB_PIN_COUNT = "Set RGB string, number of lights";
|
||
En.MIXLY_RGB_NUM_R_G_B = "Set RGB light, R value, B value, G value";
|
||
En.MIXLY_RGB_NUM_R_G_B_MP = "Set RGB light, R value, B value, G value, NO. from 0";
|
||
En.MIXLY_RGB_NUM_R_G_B_MIXGOCC = "Set RGB light, R value, B value, G value, NO. from 0 to 3";
|
||
En.MIXLY_RGB_ALL_R_G_B_MIXGOCC = "Set all RGB lights, R value, B value, G value";
|
||
En.MIXLY_RGB_NUM_R_G_B_MIXGOME = "Set RGB light, R value, B value, G value, NO. from 0 to 1";
|
||
En.MIXLY_RGB_NUM_R_G_B_MPYTHON = "Set RGB light, R value, B value, G value, NO. from 0 to 2";
|
||
En.MIXLY_MICROBIT_JS_SERIAL_READ_LINE1 = "Return a string of strings in the serial port";
|
||
En.MIXLY_SERIAL_AVAILABLE1 = "If the data in the serial port is readable, return true";
|
||
En.MIXLY_SERIAL_softserial = "Initialize serial input, output, baud rate";
|
||
En.MIXLY_MICROBIT_Configure_radio1 = 'Configure wireless information length, maximum number of queues, channel, broadcast power, data rate';
|
||
En.MIXLY_MICROBIT_Send_message1 = "Wireless Send String";
|
||
En.MIXLY_MICROBIT_JS_I2C_READ = "Set the address of i2c to read the number, the number of bytes";
|
||
En.MIXLY_MICROBIT_JS_I2C_READ_ADDRESS = 'i2c read number at address';
|
||
En.TEXT_PRINT_Huanhang_TOOLTIP = "Automatic Wrap";
|
||
En.MIXLY_MICROBIT_Shiliang_Direction = 'x,y,z vector and direction';
|
||
En.MIXLY_MICROBIT_Direction = 'direction';
|
||
En.MIXLY_MICROBIT_JS_ACCELERATION1 = 'Acceleration (mg)';
|
||
En.MIXLY_MIX1 = 'Year/Month/Day';
|
||
En.MIXLY_MIX2 = 'hours/minutes/seconds';
|
||
En.MIXLY_LCD_PRINT3_TOOLTIP = "";
|
||
En.MIXLY_LCD_PRINT4_TOOLTIP = "";
|
||
En.MIXLY_USE = 'to';
|
||
En.MIXLY_BELONG = '';
|
||
En.MIXLY_MICROBIT_PY_STORAGE_CAN_WRITE_ORNOT1 = 'If the file is writable, it returns true, otherwise it returns false';
|
||
En.MIXLY_MICROBIT_PY_STORAGE_GET_FILENAME = 'Get file name';
|
||
En.MIXLY_MICROBIT_IMAGE = 'image';
|
||
En.MIXLY_MICROBIT_Reset_COMPASS = 'Restore Compass Initial Settings';
|
||
En.blockpy_turtle_pencolor_hex = 'Set the brush color to hex';
|
||
En.blockpy_turtle_fillcolor_hex = 'Set the brush fill color to hex';
|
||
En.blockpy_SET_GET_AND_REMOVE_LAST = 'Get and delete one random item in the set';
|
||
En.MIXLY_blockpy_set_update = 'split set snd increase';
|
||
En.SET_TO_LISTS_TOOLTIP = "Convert the set to a list";
|
||
En.blockpy_set_add_update = 'Split increase list/string';
|
||
En.blockpy_USE_SET = 'will set';
|
||
En.SET_TO_LIST = "Convert to list";
|
||
En.DICTS_ADD_OR_CHANGE = "Add or Modify to";
|
||
En.MIXLY_TOOLTIP_LISTS_CREATE_WITH_TEXT2 = 'Create or modify a list. ';
|
||
En.PYTHON_LISTS_GET_SUBLIST_TOOLTIP = "Copy the part specified in the list.";
|
||
En.SET_UPDATE_TOOLTIP = "Split and add the contents of the list or string to the set.";
|
||
En.SET_POP_TOOLTIP = "Get and delete an item from the set.";
|
||
En.DICT_LENGTH_TOOLTIP = "Returns the number of keys in the dictionary.";
|
||
En.DICTS_CLEAR_TOOLTIP = "Convert the dictionary to an empty dictionary, retain the variables.";
|
||
En.DICTS_DEL_TOOLTIP = "Please empty the dictionary and delete the variable corresponding to the dictionary.";
|
||
En.LISTS_INDEX_FROM_START_TOOLTIP = "%1 is the first item";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_FROM = "Returns the item at the specified location in the list.";
|
||
En.LISTS_GET_RANDOM_SUBLIST_TOOLTIP = "Get random items from a sequence or set to form a list in random order.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_FROM_END = "Returns the item at the specified position in a list. #1 is the last item.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_FROM_START = "Returns the item at the specified position in a list. #1 is the first item.";
|
||
En.MIXLY_Digital_PINMODEIN = 'Digital Input';
|
||
En.MIXLY_Digital_PINMODEOUT = 'Digital Output';
|
||
En.MIXLY_Analog_PINMODEIN = 'Analog Input';
|
||
En.MIXLY_Analog_PINMODEOUT = 'Analog Output';
|
||
En.MIXLY_mSecond = 'ms';
|
||
En.MIXLY_uSecond = 'us';
|
||
En.MIXLY_TOOLTIP_INOUT_ANALOG_WRITE_SET_FREQ = 'Set pin analog output frequency';
|
||
En.MIXLY_TOOLTIP_CHAOSHENGBO = 'ultrasonic ranging (cm): trigger connector pin 15, echo connector pin 14, sclk connector pin 13';
|
||
En.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM = "Get and remove random items from the list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_INSERT = "Insert the item at the specified position in the list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_CHANGE = "Modify the item at the specified location in the list.";
|
||
En.LISTS_GET_INDEX_TOOLTIP_DELETE = "Remove items from the specified location in the list.";
|
||
En.blockpy_turtle_shape_arrow = 'arrow';
|
||
En.blockpy_turtle_shape_arrow = 'arrow';
|
||
En.blockpy_turtle_shape_turtle = 'Turtle';
|
||
En.blockpy_turtle_shape_square = 'square';
|
||
En.blockpy_turtle_shape_triangle = 'Triangle';
|
||
En.blockpy_turtle_shape_circle = 'circle';
|
||
En.blockpy_turtle_shape_classic = 'default';
|
||
En.blockpy_turtle_write = 'Write';
|
||
En.TURTLE_SHAPE_TOOLTIP = "Set the shape of the turtle, optional shapes include circles, triangles, squares, turtles, arrows and defaults.";
|
||
En.TURTLE_WRITE_TOOLTIP = "Make the turtle write the specified text at the current position on the canvas.";
|
||
En.LISTS_EXTEND_TOOLTIP = "Add the next list to the end of the previous list.";
|
||
En.MIXLY_MICROBIT_LIST_A_VALUE = 'a value';
|
||
En.MIXLY_MICROBIT_LIST_A_ITEM = 'an item';
|
||
En.MIXLY_MICROBIT_LIST_ASSIGN_AT = 'assign at';
|
||
En.MIXLY_MICROBIT_LIST_EXTEND = 'extend';
|
||
En.MIXLY_MICROBIT_LIST_POP = 'pop #';
|
||
En.TURTLE_POS_SHAPE = "Get the turtle currently";
|
||
En.TURTLE_POS = "Get the current position of the turtle";
|
||
En.TURTLE_SHAPE = "shape";
|
||
En.TURTLE_HEADING = "Heading";
|
||
En.MIXLY_TOOLTIP_TURTEL_POS = 'Get the turtle\'s current position and return a tuple containing the current position x and y coordinates';
|
||
En.MIXLY_TOOLTIP_TURTEL_SHAPE = 'Get the turtle\'s current shape and return a string';
|
||
En.MIXLY_TOOLTIP_TURTEL_GET_SPEED = "get the turtles current speed and return an integer;";
|
||
En.LISTS_CREATE_PYTHON_EMPTY_TITLE = "Initialize to an empty list";
|
||
En.LISTS_CREATE_PYTHON_EMPTY_TOOLTIP = "Return a list with a length of 0 and no data records";
|
||
En.LISTS_CREATE_WITH_PYTHON_TOOLTIP = "Create a list with any number of items.";
|
||
En.MIXLY_TOOLTIP_CONVERT_LIST_TO_TUPLE = 'Convert the list to a tuple. ';
|
||
En.MIXLY_TOOLTIP_CONVERT_LIST_TO_SET = 'Convert the list into a set. ';
|
||
En.MIXLY_TOOLTIP_CONVERT_LIST_TO_ARRAY = 'Convert the list into an array.';
|
||
En.LANG_LISTS_REVERSE_TOOLTIP = 'Reverse the order of all items in the list. ';
|
||
En.LISTS_SORT_TOOLTIP = 'Sort all the items in the list in the specified order. ';
|
||
En.MIXLY_TOOLTIP_LIST_FIND_INDEX = 'Returns the position of the specified value in the list, and returns the position of the first value if there are multiple values. ';
|
||
En.MIXLY_TOOLTIP_LIST_FIND_COUNT = 'Returns the number of specified values in the list. ';
|
||
En.MIXLY_TOOLTIP_LIST_APPEND = 'Add the specified value to the end of the list. ';
|
||
En.MIXLY_TOOLTIP_LIST_REMOVE = 'Remove the specified value from the list, delete the first one if there are multiple values in the list, and report an error if the value is not in the list. ';
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT = "Add the specified value to the specified position in the list.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST = "Inserts the item at the start of a list.";
|
||
En.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM_END = "Inserts the item at the specified position in a list. #1 is the last item.";
|
||
En.DICT_UPDATE = "Added to the dictionary";
|
||
En.MAKE_DICT = "The dictionary";
|
||
En.DICTS_UPDATE_TOOLTIP = "Add all entries in the previous dictionary to the next dictionary, the former remains unchanged.";
|
||
En.DICTS_ADD_TOOLTIP = "Add or modify an entry in the dictionary.";
|
||
En.MIXLY_TOOLTIP_TUPLE_FIND_INDEX = 'Returns the position of the specified value in the tuple, and returns the position of the first value if there are multiple values. ';
|
||
En.MIXLY_TOOLTIP_TUPLE_FIND_COUNT = 'Returns the number of specified values in the tuple. ';
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_AVERAGE = "Return the average of the values in the tuple.";
|
||
En.MIXLY_UART_SETUP = 'Initialize UART to';
|
||
En.MIXLY_TOOLTIP_BLOCKGROUP_GET_TEM_HUM = 'Return the temperature and humidity measured by the temperature and humidity sensor.';
|
||
En.MIXLY_DHT11_T_H = 'Get temperature and humidity';
|
||
En.MIXLY_RECT = 'draw rect';
|
||
En.MIXLY_RECT_START = 'starting point';
|
||
En.MIXLY_RECT_Fill = 'fill';
|
||
En.MIXLY_MICROBIT_SHOW_RECT = "Start point (x %1 , y %2 ) Width %3 Height %4 %5 Fill %6";
|
||
En.MIXLY_MICROBIT_SHOW_LINE = "Line starting point (x %1 , y %2 ) length %3 ";
|
||
En.MIXLY_DISPLAY_DRAW = 'draw';
|
||
En.MIXLY_DISPLAY_RLINE = 'level';
|
||
En.MIXLY_DISPLAY_VLINE = 'vertical';
|
||
En.MIXLY_MICROBIT_SHOW_LINE_ARBITRARILY = 'Draw a line starting point (x1 %1 , y1 %2 ) End point (x2 %3 , y2 %4 ) ';
|
||
En.MIXLY_ESP32_Create_image = 'Create image %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17 %18 %19 %20 %21 %22 %23 %24 %25 %26 %27 %28 %29 %30 %31 %32 %33 %34 %35 %36 %37 %38 %39 %40 %41 %42 %43 %44 %45 %46 %47 %48 %49 %50 %51 %52 %53 %54 %55 %56 %57 %58 %59 %60 %61 %62 %63 %64 %65 %66 %67 %68 %69 %70 %71 %72 %73 %74 %75 %76 %77 %78 %79 %80 %81 %82 %83 %84 %85 %86 %87 %88 %89 %90 %91 %92 %93 %94 %95 %96 %97 %98 %99 %100 %101 %102 %103 %104 %105 %106 %107 %108 %109 %110 %111 %112 %113 %114 %115 %116 %117 %118 %119 %120 %121 %122 %123 %124 %125 %126 %127 %128 %129 %130 %131 %132 %133 %134 %135 %136';
|
||
En.MIXLY_ESP32_JS_MONITOR_BRIGHTNESS = 'If the point (x,y) lights up, it returns true';
|
||
En.MIXLY_ESP32_JS_MONITOR_GET_POINT = 'light is on?';
|
||
En.MIXLY_ESP32_JS_MONITOR_SET_BRIGHTNESS = 'setting off';
|
||
En.MIXLY_ESP32_ON = 'On';
|
||
En.MIXLY_ESP32_OFF = 'Off';
|
||
En.MIXLY_ESP32_JS_MONITOR_SET_SCREEN_BRIGHTNESS = 'set screen brightness';
|
||
En.MIXLY_ESP32_JS_MONITOR_GET_SCREEN_BRIGHTNESS = 'get screen brightness';
|
||
En.MIXLY_ESP32_JS_MONITOR_SET_BLINK_RATE = 'Set the blinking frequency';
|
||
En.MIXLY_NETWORK_INIT = 'Config Wi-Fi';
|
||
En.MIXLY_NETWORK_MODE = 'Set Wi-Fi mode to';
|
||
En.MIXLY_NETWORK_WIFI_OPEN = 'Activate';
|
||
En.MIXLY_NETWORK_WIFI_CLOSE = 'Deactivate';
|
||
En.MIXLY_NETWORK_WIFI_FLAG = 'Network Interface';
|
||
En.MIXLY_NETWORK_WIFI_SCAN = 'Scan for available Wi-Fi';
|
||
En.MIXLY_ESP32_NETWORK_CONNECT = 'Connect Wi-Fi';
|
||
En.MIXLY_NETWORK_WIFI_CONNECT = 'Wi-Fi Connect State';
|
||
En.MIXLY_SYMBOL_QUESTION = '?';
|
||
En.MIXLY_ESP32_NETWORK_IP = 'IP address';
|
||
En.MIXLY_ESP32_NETWORK_MASK = 'subnet mask';
|
||
En.MIXLY_ESP32_NETWORK_GATEWAY = 'Gateway';
|
||
En.MIXLY_ESP32_NETWORK_STOP_CONNECT = 'Disconnect Wi-Fi';
|
||
En.MIXLY_ESP32_NETWORK_GET_WIFI = 'Get Wi-Fi';
|
||
En.MIXLY_NETWORK_WIFI_ESSID = 'Access Point Name';
|
||
En.MIXLY_NETWORK_WIFI_CHANNEL = 'Wi-Fi channel';
|
||
En.MIXLY_NETWORK_WIFI_SCAN_ATTRIBUTE = 'All Features';
|
||
En.MIXLY_ESP32_READ_LINE = 'Read a row';
|
||
En.MIXLY_PINMODEPULLDOWN = 'pull down input';
|
||
En.MIXLY_ESP32_BLUETOOTH_START = 'Enable';
|
||
En.MIXLY_ESP32_BLUETOOTH = 'Bluetooth';
|
||
En.MIXLY_ESP32_BLUETOOTH_ADV_DEV = 'Device Name';
|
||
En.MIXLY_ESP32_BLUETOOTH_FLAG = 'broadcast';
|
||
En.MIXLY_ESP32_BLUETOOTH_SCANNING = 'Scan is active?';
|
||
En.MIXLY_ESP32_BLUETOOTH_START = 'Enable';
|
||
En.MIXLY_ESP32_BDA = 'Connect to the remote GATTS server';
|
||
En.MIXLY_ESP32_BLUETOOTH_SERVICES = 'Get existing GATTS service';
|
||
En.MIXLY_ESP32_BLUETOOTH_CONNS = 'Get all current client connections';
|
||
En.MIXLY_ESP32_BLUETOOTH_SCANNING = 'Scan is active?';
|
||
En.MIXLY_ESP32_SERVICE_SETUP = 'Create GATTSService';
|
||
En.MIXLY_ESP32_ONENET_CLIENT = 'Device ID';
|
||
En.MIXLY_ESP32_ONENET_SERVER = 'Server Domain Name';
|
||
En.MIXLY_ESP32_ONENET_USERNAME = 'Product ID';
|
||
En.MIXLY_ESP32_ONENET_PASSWORD = 'Product APIKey';
|
||
En.MIXLY_ESP32_ONENET_TOPIC = 'Theme';
|
||
En.MIXLY_ESP32_ONENET_SUB = 'callback function';
|
||
En.MIXLY_ESP32_IOT_CONNECT_WIFI = 'Connect Wi-Fi';
|
||
En.MIXLY_ESP32_DISCONNECT_ONENET = 'OneNET disconnected';
|
||
En.MIXLY_ESP32_CHECK_ONENET = 'Receive and execute OneNET commands';
|
||
En.MIXLY_ESP32_PUBLISH_ONENET = 'Send information to OneNET';
|
||
En.MIXLY_ESP32_PUBLISH_ONENET_EMPTY = 'Send empty information to OneNET';
|
||
En.MIXLY_TO_BITES = 'transfer byte';
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_MAX = "Return the maximum number in the tuple.";
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_MEDIAN = "Return the median in the tuple.";
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_MIN = "Return the minimum number in the tuple.";
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_MODE = "Return the list of the most common items in the tuple.";
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_RANDOM = "Return a random element from the tuple.";
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_STD_DEV = "Return the standard deviation of the tuple.";
|
||
En.MATH_ONLIST_TOOLTIP_TUPLE_SUM = "Return the sum of all numbers in the tuple..";
|
||
En.TUPLE_DEL_TOOLTIP = "Remove tuple variables and freed storage space for tuple variables.";
|
||
En.PYTHON_TUPLE_GET_SUBLIST_TOOLTIP = "Copy the specified part of the tuple.";
|
||
En.MIXLY_ESP32_NETWORK_SERVER1 = 'Config ESP32 as Server';
|
||
En.MIXLY_ESP32_NETWORK_SERVER2 = 'Recieve message';
|
||
En.MIXLY_MICROBIT_RADIO_SEND = 'Wireless send';
|
||
En.MIXLY_MICROBIT_MSG = 'Message';
|
||
En.MIXLY_MICROBIT_MSG_BYTE = 'Message as Bytes';
|
||
En.MIXLY_MICROBIT_MSG_FULL = '(Message,Signal Strength,Timestamp)';
|
||
En.blockpy_DICT_POP = 'Get and delete keys in dictionary';
|
||
En.DICT_POP_TOOLTIP = "Get and delete the corresponding entry in the dictionary and return the deleted value.";
|
||
En.DICTS_DEFAULT_VALUE = "Config default";
|
||
En.DICTS_SET_DEFAULT = "Config key";
|
||
En.DICTS_SETDEFAULT_TOOLTIP = "Add a key and corresponding value in the dictionary, if the same name key in the dictionary is invalid.";
|
||
En.TEXT_UPPER = "Uppercase (all characters)";
|
||
En.TEXT_TITLE = 'Uppercase(for first letter of each word)';
|
||
En.TEXT_CAPITALIZE = 'Uppercase(for first letter of each sentence)';
|
||
En.TEXT_SWAPCASE = 'swapcase';
|
||
En.TEXT_LOWER = 'lowercase';
|
||
En.TEXT_LJUST = 'left alignment';
|
||
En.TEXT_CENTER = 'middle alignment';
|
||
En.AILGN_EDGE = "edge;";
|
||
En.TEXT_RJUST = 'right alignment';
|
||
En.MIXLY_MIXPY_REPLACE = 'Replace';
|
||
En.LIST_SPLIT_AS = "As";
|
||
En.LIST_SPLIT = "Split";
|
||
En.MIXLY_TOOLTIP_TEXT_SPLIT = "Divides the string into a list.";
|
||
En.TEXT_STRIM = "Strim";
|
||
En.TEXT_TRIM_BOTH = "Both";
|
||
En.TEXT_TRIM_LEFT = "Left";
|
||
En.TEXT_TRIM_RIGHT = "Right";
|
||
En.TEXT_BLANK = "Space";
|
||
En.TEXT_TRIM_BOTH_TOOLTIP = "Copy the text and delete the extra space at both ends.";
|
||
En.TEXT_TRIM_LEFT_TOOLTIP = "Copy the text while deleting the excess space on the left.";
|
||
En.TEXT_TRIM_RIGHT_TOOLTIP = "Copy the text while deleting the excess space on the Right.";
|
||
En.LIST_EQUAL_DISTANCE = "Equidistant";
|
||
En.MIXLY_LIST_LENGTH = 'Based On length';
|
||
En.blockpy_TURTLE_DONE = 'Turtle On';
|
||
En.blockpy_turtle_bgcolor_hex = 'Set the background color to sixteen hexadecimal';
|
||
En.MIXLY_TOOLTIP_SERIES_CREATE_FROM_TEXT = 'Create or modify an series with arrays or dictionaries.';
|
||
En.SERIES_INDEX_VALUE = "Get Series all item";
|
||
En.SERIES_INDEX = "index";
|
||
En.SERIES_INDEX_TOOLTIP = "Return all indexes in the serries as list";
|
||
En.SERIES_VALUE_TOOLTIP = "Returns a list including all values of a Series";
|
||
En.blockpy_series_create = 'Create series';
|
||
En.blockpy_series_create_index_TOOLTIP = 'Create a series by dictionary or list, and specify a list as index.';
|
||
En.blockpy_PYLAB_SHOW = 'Display chart';
|
||
En.blockpy_PYLAB_LEGEND = 'Display Legend';
|
||
En.blockpy_PYLAB_TITLE = 'Set chart title';
|
||
En.blockpy_PYLAB_SET_LABEL = 'Config Chart';
|
||
En.blockpy_PYLAB_LABEL = 'Coordinate description text is';
|
||
En.PYLAB_LABEL_X = "X";
|
||
En.PYLAB_LABEL_Y = "Y";
|
||
En.blockpy_series_set_index = 'Index';
|
||
En.blockpy_PYLAB_PLOT_DOT = 'Dot Type';
|
||
En.blockpy_dataframe_create = 'Create a two-dimensional data table';
|
||
En.blockpy_dataframe_via = 'By dictionary';
|
||
En.blockpy_dataframe_set_index_column = 'Index column';
|
||
En.blockpy_dataframe_set_index_raw = 'Raw column';
|
||
En.blockpy_series_create_TOOLTIP = 'Create a series by dictionary or list, indexed as the default natural number.';
|
||
En.blockpy_series_create_index_TOOLTIP = 'Create a series by dictionary or list, and specify a list as index.';
|
||
En.blockpy_dataframe_create_TOOLTIP = 'Create a two-dimensional table through the dictionary, indexed as the default natural number.';
|
||
En.blockpy_dataframe_create_index_TOOLTIP = 'Create a two-dimensional table through the dictionary and specify the list as rank index.';
|
||
En.blockpy_PYLAB_PLOT_LINE = 'Line Type';
|
||
En.blockpy_PYLAB_PLOT_LINE_SOLID = 'Solid Line';
|
||
En.blockpy_PYLAB_PLOT_LINE_DOTTED = 'Dotted Line';
|
||
En.blockpy_PYLAB_PLOT_LINE_CHAIN = 'Chain Line';
|
||
En.blockpy_PYLAB_PLOT_LINE_POINT_DOTTED = 'Point dotted Line';
|
||
En.mixpy_PYLAB_PLOT_XY = "draw line chart;";
|
||
En.mixpy_PYLAB_SCATTER = 'Draw a scatterplot;';
|
||
En.mixpy_SUBPLOT = "split sub graph;";
|
||
En.mixpy_SUBPLOT_VERTICLE = "split up and down;";
|
||
En.mixpy_SUBPLOT_HORIZEN = "left and right parts are divided into;";
|
||
En.mixpy_SUBPLOT_NUM = "active parts;";
|
||
En.mixpy_PYLAB_BAR = "draw bar chart;";
|
||
En.mixpy_PYLAB_HIST = "draw histogram;";
|
||
En.mixpy_PYLAB_PIE = 'draw Pie';
|
||
En.mixpy_PYLAB_BAR_ALIGN = "alignment;";
|
||
En.mixpy_PYLAB_PLOT_X = "draw line chart;";
|
||
En.mixpy_PYLAB_PLOT_Y = "dependent variable;";
|
||
En.mixpy_PYLAB_PLOT_XY_TOOLTIP = "draw a line chart with the specified arguments and dependent variables, which can be lists, arrays, tuples, etc.;";
|
||
En.mixpy_PYLAB_PLOT_BAR_PLOT = "broken line chart;";
|
||
En.mixpy_PYLAB_PLOT_BAR_BAR = "Bar chart;";
|
||
En.mixpy_PYLAB_PLOT_BAR_EASY_TOOLTIP = "draw bar chart with specified arguments and dependent variables, which can be list, array, tuple, etc.;";
|
||
En.mixpy_PYLAB_HIST_TOOLTIP = "draw histogram with specified data set and partition points, which can be list, array, tuple, etc.;";
|
||
En.mixpy_PYLAB_TICKS = "axis scale;";
|
||
En.mixpy_PYLAB_TICKS_TAG = "label;";
|
||
En.mixpy_PYLAB_TICKS_TOOLTIP = "set label content of axis;";
|
||
En.mixpy_NUMPY_TRIG = "array operation;";
|
||
En.mixpy_NUMPY_TRIG_TOOLTIP = "perform the specified operation for each item in the array or list, and the result returns an array;";
|
||
En.mixpy_PANDAS_READCSV_TITLE = "heading line;";
|
||
En.mixpy_PANDAS_READCSV_HEADER_Y = "inclusive;";
|
||
En.mixpy_PANDAS_READCSV_HEADER_N = "does not contain;";
|
||
En.mixpy_PANDAS_READCSV_TOOLTIP = "read the content of the specified CSV file into a variable. The variable type is dataframe. If you choose to include a header row, the first row of the CSV file will be the header by default;";
|
||
En.mixpy_DATAFRAME_GET = "Get label;";
|
||
En.mixpy_DATAFRAME_GET_INDEX = "Corresponding;";
|
||
En.mixpy_DATAFRAME_GET_TOOLTIP = "Get row or column of dataframe by title or index name;";
|
||
En.mixpy_PL_SAVEFIG = "Save the drawn graphic as a picture";
|
||
En.mixpy_PL_SAVEFIG_TOOLTIP = "Save the drawn graphics, the parameters can set the path, name and extension of the saved image";
|
||
En.mixpy_TURTLE_SAVEFIG_TOOLTIP = "Save the drawn graphics through the turtle screen. The supported file format is .eps. You need to initialize the turtle screen in advance.";
|
||
En.mixpy_PL_TEXT_X = "abscissa;";
|
||
En.mixpy_PL_TEXT_Y = "ordinate;";
|
||
En.mixpy_PL_TEXT_TAG = "The data label at is;";
|
||
En.mixpy_PL_TEXT_TOOLTIP = "set the value label of the specified location;";
|
||
En.mixpy_PL_AXES = "set equal length of horizontal and vertical axes;";
|
||
En.mixpy_PL_TEXT_CENTER = "median;";
|
||
En.mixpy_PL_TEXT_TOP = "top;";
|
||
En.mixpy_PL_TEXT_BOTTOM = "below;";
|
||
En.mixpy_PL_TEXT_HOR = "horizontal at point;";
|
||
En.mixpy_PL_TEXT_VER = "vertically at point;";
|
||
En.mixpy_PL_PIE_SHADOW_Y = "yes;";
|
||
En.mixpy_PL_PIE_SHADOW_N = "no;";
|
||
En.mixpy_PYLAB_PIE_EXPLODE = "centrifugal distance;";
|
||
En.mixpy_PYLAB_PIE_SHADOW = "shadow;";
|
||
En.mixpy_PYLAB_PIE_AUTOPCT = "data label;";
|
||
En.mixpy_PYLAB_PIE_AUTOPCT_Z = "keep Integer;";
|
||
En.mixpy_PYLAB_PIE_AUTOPCT_O = "keep one decimal place;";
|
||
En.mixpy_PYLAB_PIE_AUTOPCT_Z = "keep Integer;";
|
||
En.COLOUR_CYAN = "Cyan";
|
||
En.COLOUR_MAGENTA = "Magenta";
|
||
En.COLOUR_YELLOW = "Yellow";
|
||
En.COLOUR_BLACK = "Black";
|
||
En.COLOUR_WHITE = "White";
|
||
En.blockpy_PYLAB_PLOT_DOT = 'Dot Type';
|
||
En.blockpy_PYLAB_PLOT_DOT_CIRCULAR = 'Circular';
|
||
En.blockpy_PYLAB_PLOT_DOT_LARGE_DOT = 'Large';
|
||
En.blockpy_PYLAB_PLOT_DOT_PIXEL = 'Pixel Doy';
|
||
En.blockpy_PYLAB_PLOT_DOT_TRIANGLE_UP = 'Triangle Up';
|
||
En.blockpy_PYLAB_PLOT_DOT_LARGE_DOT = 'Large';
|
||
En.blockpy_PYLAB_PLOT_DOT_TRIANGLE_LEFT = 'Triangle Left';
|
||
En.blockpy_PYLAB_PLOT_DOT_TRIANGLE_RIGHT = 'Triangle Right';
|
||
En.blockpy_PYLAB_PLOT_DOT_TRIMARKER_UP = 'Trimaker Up';
|
||
En.blockpy_PYLAB_PLOT_DOT_TRIMARKER_DOWN = 'Trimaker Down';
|
||
En.blockpy_PYLAB_PLOT_DOT_TRIMARKER_LEFT = 'Trimaker Left';
|
||
En.blockpy_PYLAB_PLOT_DOT_TRIMARKER_RIGHT = 'Trimaker Right';
|
||
En.blockpy_PYLAB_PLOT_DOT_SQUARE = 'Square';
|
||
En.blockpy_PYLAB_PLOT_DOT_PENTAGON = 'Pentagon';
|
||
En.blockpy_PYLAB_PLOT_DOT_STAR = 'Star';
|
||
En.blockpy_PYLAB_PLOT_DOT_HEXAGON_VERTICAL = 'Hexagon Vertical';
|
||
En.blockpy_PYLAB_PLOT_DOT_HEXAGON_HORIZONTAL = 'Hexagon Horizontal';
|
||
En.blockpy_PYLAB_PLOT_DOT_PLUS = 'Plus';
|
||
En.blockpy_PYLAB_PLOT_DOT_CROSS = 'Cross';
|
||
En.blockpy_PYLAB_PLOT_DOT_DIAMOND = 'Big Diamond';
|
||
En.blockpy_PYLAB_PLOT_DOT_DIAMOND_SMALL = 'Small Diamond';
|
||
En.blockpy_PYLAB_PLOT_DOT_VERTICAL = 'Vertical';
|
||
En.blockpy_PYLAB_PLOT_DOT_HORIZONTAL = 'Horizontal';
|
||
En.MIXLY_MICROBIT_JS_I2C = 'i2c';
|
||
En.MIXLY_ESP32_TOUCH = 'Touch';
|
||
En.MIXLY_ESP32_TOUCH_SENSOR = 'Touch Sensor';
|
||
En.MIXLY_ESP32_NEAR = "Infrared distance sensor value";
|
||
En.MIXLY_ESP32_NEAR_BOOL = "Infrared distance sensor is blocked";
|
||
En.MIXLY_ESP32_EXTERN_NEAR = "Return infrared distance sensor value";
|
||
En.MIXLY_ESP32_INTERRUPT = 'Interrupt';
|
||
En.MIXLY_ESP32_PITCH = 'Pitch';
|
||
En.MIXLY_ESP32_DUTY = 'Tone';
|
||
En.MIXLY_ESP32_LIGHT = 'Return light value';
|
||
En.MIXLY_ESP32_SOUND = 'Return sound value';
|
||
En.MIXLY_ESP32_MONITOR_SCROLL = 'Scroll';
|
||
En.MIXLY_PYTHON_GLOBAL = 'Global variable';
|
||
En.MIXLY_ESP32_TOGGLE = 'Change';
|
||
En.MIXLY_PYTHON_ONE_SHOT = 'One Shot';
|
||
En.MIXLY_PYTHON_PERIODIC = 'Periodic';
|
||
En.MIXLY_RTC_TIME = 'Config RTC';
|
||
En.blockpy_REQUESTS_GET = 'Initiating get request receive as variable';
|
||
En.blockpy_REQUESTS_GET_ATTR_CONTENT = 'Bin content';
|
||
En.blockpy_REQUESTS_GET_ATTR_STATUS_CODE = 'Status Code';
|
||
En.blockpy_REQUESTS_GET_ATTR_TEXT = 'Response content';
|
||
En.blockpy_REQUESTS_GET_ATTR_CONTENT = 'Bin content';
|
||
En.blockpy_REQUESTS_GET_ATTR_COOKIES = 'cookies';
|
||
En.blockpy_REQUESTS = 'Request';
|
||
En.blockpy_CONDUCT = 'Conduct';
|
||
En.MIXLY_ESP32_TIME_TICKS_DIFF = 'Time Diff'
|
||
En.MIXLY_ESP32_TIME_MINUS = 'Minus'
|
||
En.MIXLY_ESP32_MACHINE_VALUE = 'value'
|
||
En.MIXLY_ESP32_RGB_WRITE = 'take effect'
|
||
En.MIXLY_GETPRESSURE = 'Return atmospheric pressure';
|
||
En.MIXLY_MICROPYTHON_AS = "As";
|
||
En.MIXLY_ESP32_ONEWIRE_SCAN = "Scan";
|
||
En.MIXLY_ESP32_ONEWIRE_RESET = 'Reset OneWire';
|
||
En.MIXLY_ESP32_ONEWIRE_READ = "Read byte";
|
||
En.MIXLY_ESP32_ONEWIRE_INIT = "Init bus";
|
||
En.MIXLY_ESP32_ONEWIRE_SELECT = "Config OneWire";
|
||
En.MIXLY_ESP32_I2C_SCAN1 = "Scan I2C";
|
||
En.MIXLY_ESP32_I2C_SCAN2 = "Devices on Bus";
|
||
En.MIXLY_ESP32_SPI_SET = "Config SPI Baudrate";
|
||
En.MIXLY_ESP32_SPI_BUFFER = "Buffer";
|
||
En.MIXLY_ESP32_SPI_OUTPUT = "OutPut";
|
||
En.MIXLY_ESP32_SET = "Create";
|
||
En.MIXLY_ESP32_WRITE = "Write";
|
||
En.MIXLY_ESP32_BUFFER_READ = "Read into Buffer";
|
||
En.MIXLY_ESP32_WNUMBER = "Write address";
|
||
En.MIXLY_ESP32_RNUMBER = "Read address";
|
||
En.MIXLY_ESP32_READ = "Read";
|
||
En.MIXLY_ESP32_SUCCESS = "Success？";
|
||
En.MIXLY_ESP32_SPI_INIT = "Init SPI";
|
||
En.MIXLY_ESP32_REF_VOLTAGE = "Ref Voltafe";
|
||
En.MIXLY_TOOLTIP_DISPLAY_ONOFF = 'Return Led state';
|
||
En.MIXLY_MICROPYTHON_SOCKET_INIT = 'Socket Init ';
|
||
En.MIXLY_MICROPYTHON_SOCKET_TYPE = 'Socket Type';
|
||
En.MIXLY_MICROPYTHON_SOCKET_LISTEN = 'Socket Listen';
|
||
En.MIXLY_MICROPYTHON_SOCKET_QUEUE = 'Socket Queue';
|
||
En.MIXLY_MICROPYTHON_SOCKET_LET_SOCKET = 'Set Socket';
|
||
En.MIXLY_MICROPYTHON_SOCKET_BIND_TO_ADDRESS = 'Bind to address';
|
||
En.MIXLY_MICROPYTHON_SOCKET_ACCEPT = 'Accept and return Socket';
|
||
En.MIXLY_MICROPYTHON_SOCKET_RECEIVE = 'Socket Recieve';
|
||
En.MIXLY_MICROPYTHON_SOCKET_SEND = 'Send';
|
||
En.MIXLY_MICROPYTHON_SOCKET_MAKE = "Set";
|
||
En.MIXLY_MICROPYTHON_SOCKET_TO = "To";
|
||
En.MIXLY_MICROPYTHON_SOCKET_CLOSE = "Close";
|
||
En.MIXLY_ESP32_MONITOR_GET_SCREEN_IMAGE = 'Return matrix bitmap';
|
||
En.MIXLY_ESP32_MONITOR_GET_SCREEN_IMAGE_TOOLTIP = 'Return matrix bitmap';
|
||
En.MIXLY_ESP32_MONITOR_SHOW_STATIC = 'Display String Static';
|
||
En.MIXLY_ESP32_SENOR_GYRO = 'GYPO(rad/s)';
|
||
En.DATAFRAME_RAW = "Raw";
|
||
En.DATAFRAME_COLUMN = "Column";
|
||
En.MIXLY_ESP32_MUSIC_PLAY_LISTS = 'playlist';
|
||
En.MIXLY_ESP32_MUSIC_WAIT = 'wait';
|
||
En.MIXLY_ESP32_MUSIC_LOOP = 'loop';
|
||
En.MIXLY_ESP32_MIXGO_MUSIC_PLAY_TONE = 'show note';
|
||
En.MIXLY_ESP32_MIXGO_MUSIC_SHOW_IN = 'in';
|
||
En.MIXLY_MICROPYTHON_CLEAR = 'empty';
|
||
En.MIXLY_MICROPYTHON_FORMAT = 'format string';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_ALL = 'Current time';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_DATE = 'Current date';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_HOUR = 'Current hour';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_MINUTE = 'Current minute';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_MONTH = 'Current month';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_SECOND = 'Current second';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_YEAR = 'Current year';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_ALL = 'Current time';
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_INWEEK = "Current day of the week";
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_INYEAR = "Current day of the year";
|
||
En.MIXLY_SYSTEM_TIME_LOCALTIME_DST = "Current daylight saving time mark";
|
||
En.MIXLY_TURTLE_SCREEN_DELAY = 'Set the animation playback interval to';
|
||
En.MIXLY_TOOLTIP_TURTEL_SCREEN_DELAY = 'Set the refresh interval of the turtle painting animation playback, the default is 10, the smaller the value, the faster the animation playback';
|
||
En.MIXLY_TURTLE_WRITE_MOVE = 'move with text';
|
||
En.MIXLY_TURTLE_WRITE_MOVE_TRUE = 'yes';
|
||
En.MIXLY_TURTLE_WRITE_MOVE_FALSE = 'no';
|
||
En.MIXLY_TURTLE_WRITE_ALIGN = 'align';
|
||
En.MIXLY_TURTLE_WRITE_ALIGN_LEFT = 'left';
|
||
En.MIXLY_TURTLE_WRITE_ALIGN_CENTER = 'center';
|
||
En.MIXLY_TURTLE_WRITE_ALIGN_RIGHT = 'right';
|
||
En.MIXLY_TURTLE_WRITE_FONT_NAME = 'font';
|
||
En.MIXLY_TURTLE_WRITE_FONT_NUM = 'size';
|
||
En.MIXLY_TURTLE_WRITE_FONT_TYPE = 'type';
|
||
En.MIXLY_TURTLE_WRITE_FONT_TYPE_NORMAL = 'stanard';
|
||
En.MIXLY_TURTLE_WRITE_FONT_TYPE_BOLD = 'bold';
|
||
En.MIXLY_TURTLE_WRITE_FONT_TYPE_ITALIC = 'italic';
|
||
En.MIXLY_TURTLE_WRITE_FONT_TYPE_BOLD_ITALIC = 'bold italic';
|
||
En.MIXLY_ESP32_I2C_INIT = "Initialize I2C, sda is a data signal, scl is a clock signal, and the frequency is the data transmission rate is generally 10k or 40k";
|
||
En.MIXLY_ESP32_I2C_SCAN = "Search for devices on the I2C bus and return the device address";
|
||
En.MIXLY_ESP32_I2C_AVAILABLE = "Judge whether I2C read data successfully, return true / false";
|
||
En.MIXLY_ESP32_SPI_INIT_TOOLTIP = "Create SPI object and set baudrate, (clock) polarity: 0/1, (clock) phase: 0/1, and clock (SCK), master device Output, Slave Device Input (MOSI), Master Device Input, Slave Device Output (MISO) pins ";
|
||
En.MIXLY_ESP32_SPI_BUFFER_SET = "Create a buffered byte stream and set its size";
|
||
En.MIXLY_ESP32_SPI_READ = "Returns the bytes read by SPI (fill in the number of bytes read)";
|
||
En.MIXLY_ESP32_SPI_READ_OUTPUT = "Read a certain number of bytes and return when outputting 0xFF on MOSI";
|
||
En.MIXLY_ESP32_SPI_READINTO = "Return the buffered byte stream read (the length was set when the buffered byte stream was created)";
|
||
En.MIXLY_ESP32_SPI_READINTO_OUTPUT = "Read the given buffered byte stream and output 0xff on MOSI";
|
||
En.MIXLY_ESP32_SPI_WRITE = "SPI Send Byte";
|
||
En.MIXLY_ESP32_SPI_WRITE_READINTO = "SPI sends bytes and reads them into a buffered byte stream";
|
||
En.MIXLY_ESP32_OW_INIT = "Create a single bus protocol on a pin";
|
||
En.MIXLY_ESP32_OW_SCAN = "Return a list of devices on the bus";
|
||
En.MIXLY_ESP32_OW_READ = "Read a byte on the bus";
|
||
En.MIXLY_ESP32_OW_WRITE = "Write a string / byte on the bus";
|
||
En.MIXLY_ESP32_OW_SELECT = "Select a specific device by ROM code";
|
||
En.MIXLY_ESP32_OW_RESET = "Reset the bus";
|
||
En.MIXLY_ESP32_SERVO_MOVE = 'Set the rotation angle of the servo (0 ~ 180 °)';
|
||
En.MIXLY_ESP32_SERVO_SPEED_TOOLIPS = 'Set the rotation speed of the servo(-100~100%)';
|
||
En.MIXLY_ESP32_LED_SETONOFF = "Set the status of the embedded LED light";
|
||
En.MIXLY_ESP32_LED_GETONOFF = "Get the current status of the embedded LED light";
|
||
En.MIXLY_ESP32_LED_SETBRIGHT = "Set the current brightness of the embedded LED light (0 ~ 1023)";
|
||
En.MIXLY_ESP32_MUSIC_PLAYSHOW = "Play the note list and display the corresponding note";
|
||
En.MIXLY_ESP32_MUSIC_SET_TEMPO = "Set the resolution and speed of playing music";
|
||
En.MIXLY_ESP32_MUSIC_GET_TEMPO = "Get the current rhythm of the music";
|
||
En.MIXLY_ESP32_MUSIC_RESET = "Restore the initial settings of the resolution and speed of the music";
|
||
En.MIXLY_ESP32_MUSIC_WRI = "Enable all settings related to RGB lights";
|
||
En.MIXLY_ESP32_MUSIC_SHOW_STATIC = "Display a static string on the screen";
|
||
En.MIXLY_ESP32_DISPLAY_SETPIXEL = "Set the on / off state of the LED dot matrix light at the (x, y) position";
|
||
En.MIXLY_ESP32_SHOW_IMAGE_OR_STRING_DELAY = "Display image / string over time";
|
||
En.MIXLY_ESP32_SCROLL_IMAGE_OR_STRING_DELAY = "Scroll image / string over a period of time";
|
||
En.MIXLY_OLED_RECT = "Draw a rectangle with a set vertex and length";
|
||
En.MIXLY_OLED_LINE = "Draw a line with a set vertex and length";
|
||
En.MIXLY_OLED_LINE_ARBIT = "Draw a line with a set start and end point";
|
||
En.MIXLY_ESP32_SENSOR_LIGHT_LEVEL_TOOLTIP = "Set the sensor brightness level";
|
||
En.MIXLY_ESP32_SENSOR_RTC_INT_TOOLTIP = "Initialize the real-time clock";
|
||
En.MIXLY_ESP32_RTC_SET_DATATIME_TOOLTIP = "Set the real-time clock module time";
|
||
En.MIXLY_ESP32_RTC_GET_TIME_TOOLTIP = "Time to return real-time clock"
|
||
En.MIXLY_ESP32_NETWORK_INIT_TOOLTIP = "Set the working mode of Wi-Fi and initialize Wi-Fi";
|
||
En.MIXLY_ESP32_NETWORK_OPEN_TOOLTIP = "Network connection";
|
||
En.MIXLY_ESP32_NETWORK_SCAN_TOOLTIP = "Return to connectable Wi-Fi";
|
||
En.MIXLY_ESP32_NETWORK_CONNECT_TOOLTIP = "Set Wi-Fi name and password";
|
||
En.MIXLY_ESP32_NETWORK_WIFI_CONNECT_TOOLTIP = "Returns true when Wi-Fi is connected";
|
||
En.MIXLY_ESP32_NETWORK_GET_CONNECT_TOOLTIP = "Return the connected Wi-Fi address";
|
||
En.MIXLY_ESP32_NETWORK_STOP_TOOLTIP = "Disconnect Wi-Fi";
|
||
En.MIXLY_ESP32_NETWORK_GET_WIFI_TOOLTIP = "Return Wi-Fi connection name";
|
||
En.MIXLY_ESP32_NETWORK_AP_CONNECT_TOOLTIP = "Set the name of the access point";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_INIT_TOOLTIP = "Set the network connection protocol to";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_BIND_TOOLTIP = "Bind the socket to a network address";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_LISTEN_TOOLTIP = "Listen for incoming connections";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_ACCEPT_TOOLTIP = "Accepts the connection and returns the connected object";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_RECEIVE_TOOLTIP = "Return received data using TCP protocol";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_SEND_TOOLTIP = "Send information using TCP protocol";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_RECEIVE_FROM_TOOLTIP = "Return received data using UDP protocol";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_SEND_TO_TOOLTIP = "Send information to the specified network address";
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_CLOSE_TOOLTIP = "Close network connection";
|
||
En.MIXLY_ESP32_SENSOR_MIXGO_PIN_NEAR_TOOLTIP = 'Return'
|
||
En.ESP32_SENSOR_NIXGO_LIGHT_TOOLTIP = 'Return the value of the light sensor (0 ~ 65535)';
|
||
En.ESP32_SENSOR_NIXGO_SOUND_TOOLTIP = 'Return the value of the sound sensor (0 ~ 65535)';
|
||
En.MIXLY_MICROBIT_SENSOR_BMP_temperature_TOOLTIP = "Get the temperature of DS18X20 (℃)";
|
||
En.MIXLY_MICROBIT_SENSOR_BMP_press_TOOLTIP = "Get atmospheric pressure (0 ~ 20000hPa)";
|
||
En.MIXLY_MICROBIT_SENSOR_SHT_temperature_TOOLTIP = "Get temperature (-40 ~ + 125 ℃)";
|
||
En.MIXLY_MICROBIT_SENSOR_SHT_HUM_TOOLTIP = "Get Humidity (0 ~ 100%)";
|
||
En.MIXLY_ESP32_SENSOR_USE_I2C_TOOLTIP = 'Initial sensor type is:';
|
||
En.MIXLY_MICROBIT_SENSOR_DS18X20_TOOLTIP = 'Return temperature, the range is (-55 ~ + 125 ℃)';
|
||
En.MIXLY_TOOLTIP_RTC_SETTIME = En.MIXLY_RTCSETTIME;
|
||
En.MIXLY_TOOLTIP_RTC_SETDATE = En.MIXLY_RTCSETDATE;
|
||
En.MIXLY_TOOLTIP_RGB_INIT = En.MIXLY_RGB_PIN_COUNT;
|
||
En.MIXLY_TOOLTIP_RGB_DISPLAY = En.MIXLY_RGB_NUM_R_G_B;
|
||
En.MIXLY_ESP32_INOUT_HIGHLOW_TOOLTIP = "Returns high (1) or low (0)";
|
||
En.MIXLY_ESP32_INOUT_DIGITAL_INIT_TOOLTIP = "Initialize a pin as a digital output pin";
|
||
En.MIXLY_ESP32_INOUT_DIGITAL_WRITE_TOOLTIP = "Set the digital output value of a certain pin";
|
||
En.MIXLY_ESP32_INOUT_DIGITAL_READ_TOOLTIP = "Get the digital input value of a certain pin";
|
||
En.MIXLY_ESP32_INOUT_ANALOG_READ_INIT_TOOLTIP = "Initialize a pin as a pin for analog input";
|
||
En.MIXLY_ESP32_INOUT_ANALOG_ATTEN_TOOLTIP = "Set the reference voltage of the analog input to 3.3V, 2.2V, 1.5V or 1.2V";
|
||
En.MIXLY_ESP32_INOUT_ANALOG_READ_TOOLTIP = "Get the value of analog input (0 ~ 65535)";
|
||
En.MIXLY_ESP32_INOUT_PWM_ANALOG_WRITE_INIT_TOOLTIP = "Initialize a pin as an analog output pin";
|
||
En.MIXLY_ESP32_INOUT_PWM_ANALOG_WRITE_TOOLTIP = "Set the value of a pin\'s analog output (0 ~ 65535)";
|
||
En.MIXLY_ESP32_INOUT_PWM_ANALOG_WRITE_SET_FREQ_TOOLTIP = "Set the frequency of a pin's analog output (1 ~ 78125)";
|
||
En.MIXLY_ESP32_INOUT_PIN_PRESSED_INIT_TOOLTIP = "Initialize a pin as a touch sensor pin";
|
||
En.MIXLY_ESP32_INOUT_PIN_PRESSED_TOOLTIP = "Get the value of a pin touch sensor";
|
||
En.MIXLY_ESP32_INOUT_PIN_ATTACHINTERRUPT_TOOLTIP = "Set the mode of a pin interrupt to rise, fall or change, and set a callback function";
|
||
En.MIXLY_ESP32_INOUT_ANALOG_WRITE_INIT_TOOLTIP = "Initialize a pin as a pin for analog output";
|
||
En.MIXLY_ESP32_INOUT_ANALOG_WRITE_TOOLTIP = "Set the value of the analog output of a pin";
|
||
En.MIXLY_ESP32_THRESHOLD = "Threshold";
|
||
En.MIXLY_TOUCHATTACHINTERRUPT_PIN = 'Touch interrupt pin';
|
||
En.MIXLY_ESP32_HW_TIMER = 'Hardware timer number #';
|
||
En.MIXLY_PYTHON_CONTROLS_PASS_TOOLTIP = "Skip";
|
||
En.MIXLY_PYTHON_CONTROLS_RANGE_TOOLTIP = "Return a sequence of integers, excluding the numbers at the end. All three parameters in the module should be integers";
|
||
En.MIXLY_PYTHON_CONTROLS_FOR_RANGE_TOOLTIP = "Take the value of the variable “%1” from the starting number to the ending number and execute the specified block at the specified interval";
|
||
En.MIXLY_ESP32_SYSTEM_TIMER_TOOLTIP = "Set the interval of a timer to a certain value, the mode is single or multiple triggers, and the callback function is a function";
|
||
En.MIXLY_ESP32_SYSTEM_TIMER_INIT_TOOLTIP = "Initialize a timer";
|
||
En.MIXLY_PYTHON_CONTROLS_FLOW_STATEMENTS_TOOLTIP = "Break out of the loop";
|
||
En.MIXLY_ESP32_CONTROLS_MILLIS_TOOLTIP = "Get system runtime";
|
||
En.MIXLY_ESP32_SYSTEM_TICKS_DIFF_TOOLTIP = "Get the difference between two times";
|
||
En.MIXLY_MIXPY_INOUT_STR_INPUT_TOOLTIP = 'Receive keyboard input, end with a carriage return, the content is automatically converted to a string, prompt is the input prompt provided to the user';
|
||
En.MIXLY_MIXPY_INOUT_INT_INPUT_TOOLTIP = 'Receive keyboard input, end with a carriage return, the content is automatically converted to an integer, and prompt is the input prompt provided to the user';
|
||
En.MIXLY_MIXPY_INOUT_FLOAT_INPUT_TOOLTIP = 'Receive keyboard input, end with a carriage return, the content is automatically converted to decimals, prompt is an input prompt provided to the user';
|
||
En.MIXLY_MIXPY_CONTROL_END_TOOLTIP = 'Terminate the program';
|
||
En.MIXLY_MIXPY_CONTROL_TRY_TOOLTIP = "Try to execute a statement and execute some commands according to the correctness of the statement";
|
||
En.MIXLY_MIXPY_CONTROL_EXCEPT_TOOLTIP = "Statement executed if there is an error in the statement attempted";
|
||
En.MIXLY_MIXPY_CONTROL_FINALLY_TOOLTIP = "Statements executed regardless of whether there is an error in the statement attempted";
|
||
En.MIXLY_MIXPY_TEXT_UPPER_TOOLTIP = "Converts all letters in a string to uppercase";
|
||
En.MIXLY_MIXPY_TEXT_TITLE_TOOLTIP = "Convert all the first letters of each word in a string to uppercase letters";
|
||
En.MIXLY_MIXPY_TEXT_CAPITALIZE_TOOLTIP = "Convert all the first letters of each sentence in a string into uppercase letters";
|
||
En.MIXLY_MIXPY_TEXT_SWAPCASE_TOOLTIP = "Convert all lowercase letters in a string to uppercase letters, and all uppercase letters to lowercase letters";
|
||
En.MIXLY_MIXPY_TEXT_LOWER_TOOLTIP = "Convert all characters in a string to lowercase letters";
|
||
En.MIXLY_MIXPY_TEXT_CENTER_TOOLTIP = "Set the alignment of a string and fill all blanks with symbols";
|
||
En.MIXLY_MIXPY_TEXT_FIND_TOOLTIP = "Returns a number representing the first occurrence of a character in a string";
|
||
En.MIXLY_MIXPY_TEXT_REPLACE_TOOLTIP = "Replace the specified content in a string with the corresponding content";
|
||
En.MIXLY_MIXPY_TEXT_SPLIT_TOOLTIP = "Split a string into multiple strings with the specified characters and return a list containing these substrings";
|
||
En.MIXLY_MIXPY_TURTLE_TEXTINPUT = 'Sea Turtle Gets User Input String';
|
||
En.MIXLY_MIXPY_TURTLE_TEXTINPUT_TITLE = 'The title of the input box is';
|
||
En.MIXLY_MIXPY_TURTLE_TEXTINPUT_PROMPT = 'User prompt is';
|
||
En.TURTLE_TEXTINPUT_TOOLTIP = "Pop up a dialog box to get the user input string, the two parameters are the dialog title and the user\'s input prompt";
|
||
En.MIXLY_MIXPY_TURTLE_NUMINPUT = 'Sea Turtle Gets User-Entered Floating-Point Number';
|
||
En.TURTLE_NUMINPUT_TOOLTIP = "Pop up a dialog box to get the floating point number entered by the user, the parameters are the dialog box title, the user\'s input prompt, the user's default value, the minimum value and the maximum value";
|
||
En.MIXLY_MIXPY_TURTLE_DRAW_CIRCLE = 'Draw a circle';
|
||
En.MIXLY_MIXPY_TURTLE_SETXY = 'Coordinates set to';
|
||
En.MIXLY_MIXPY_TURTLE_SETXY_TOOLTIP = 'Command the turtle to the specified horizontal and vertical coordinate position';
|
||
En.LANG_MATH_FLOAT_RANDOM = 'Decimal (left open right close)';
|
||
En.MIXLY_MIXPY_TEXT_FORMAT_TOOLTIP = 'Replace the content at the specified position of the first string parameter with the corresponding parameter and return the resulting string';
|
||
En.TEXT_RANDOM_CHAR = "Random one character";
|
||
En.TEXT_RANDOM_CHAR_TOOLTIP = "Returns a random character in a string";
|
||
En.LANG_LISTS_CLEAR_TOOLTIP = 'Remove all items from the list, making it an empty list. ';
|
||
En.MIXLY_TOOLTIP_TUPLE_SUM = 'Return the sum of all values in the tuple';
|
||
En.MIXLY_ESP32_IOT_WIFI_CONNECT_TOOLTIP = "Connect to Wi-Fi with the name XX, and the password XX";
|
||
En.MIXLY_ESP32_IOT_ONENET_CONNECT_TOOLTIP = "Create a onenet connection";
|
||
En.MIXLY_ESP32_IOT_ONENET_DISCONNECT_TOOLTIP = "Disconnect a onenet connection";
|
||
En.MIXLY_ESP32_IOT_ONENET_CHECK_TOOLTIP = "Make a onenet connection receive and execute instructions";
|
||
En.MIXLY_ESP32_IOT_ONENET_PUBLISH_DICT_TOOLTIP = "Let a onenet connection send a dictionary";
|
||
En.MIXLY_ESP32_IOT_ONENET_PUBLISH_TOOLTIP = "Let a certain onenet connection send a message";
|
||
En.MIXLY_MICROPYTHON_TYPE_COMPLEX = "plural";
|
||
En.TEXT_LINES_TOOLTIP = "Multiline Text";
|
||
En.MIXLY_MIXPY_LISTS_REMOVE = 'Remove specified items';
|
||
En.MIXLY_MIXPY_INOUT_PRINT_EMPTY = 'Cursor Wrap';
|
||
En.MIXLY_MIXPY_INOUT_PRINT_MANY_ITEM_TOOLTIP = 'Drag item into or out of the block on the right to change the number of printed parameters';
|
||
En.MIXLY_MIXPY_INOUT_PRINT_MANY_CONTAINER_TOOLTIP = "Add, delete, or rearrange sections to reconfigure this block";
|
||
En.MIXLY_MIXPY_INOUT_PRINT_MANY_TOOLTIP = 'Print multiple parameters. If the number of parameters is 0, move the cursor down one line';
|
||
En.MIXLY_HANDBIT_DISLPAY_OLED_FILL = 'Full';
|
||
En.MIXLY_PYTHON_CONTROLS_THREAD_START = 'Start thread';
|
||
En.MIXLY_PYTHON_CONTROLS_THREAD_USE = 'Call function';
|
||
En.MIXLY_PYTHON_CONTROLS_THREAD_TOOLTIP = 'Start a new thread and call the function with the given parameters (put in a tuple)';
|
||
En.MIXLY_ESP32_SHOW_IMAGE_OR_STRING_OR_ANIMATION = 'Display (Image / String / Animation)';
|
||
En.MIXLY_ESP32_SHOW_IMAGE_OR_STRING = 'display (image / string)';
|
||
En.MIXLY_MIXPY_TURTLE_WIDTH = 'Brush width';
|
||
En.MIXLY_TOOLTIP_TURTEL_HEADING = 'Get the current orientation of the turtle and return a floating point number';
|
||
En.MIXLY_TOOLTIP_TURTEL_WIDTH = 'Get the turtle\'s current pen width and return an integer';
|
||
En.MIXLY_PYTHON_TEXT_EVAL = 'Get string';
|
||
En.MIXLY_PYTHON_TEXT_EVAL_RESULT = 'Execution result';
|
||
En.MIXLY_PYTHON_TEXT_EVAL_TOOLTIP = 'Get the return value of the parameter code execution, if the parameter code has no return value, return None';
|
||
En.MIXLY_PYTHON_OS_SYSTEM = 'Execute system instructions';
|
||
En.MIXLY_PYTHON_OS_SYSTEM_TOOLTIP = 'Convert string to command and run it on the system. When each system instruction is executed, a subprocess will be created. The execution result of subprocess will not affect the main process';
|
||
En.MIXLY_PYTHON_TEXT_JOIN_SEQ_USE_STR = 'Using string';
|
||
En.MIXLY_PYTHON_TEXT_JOIN_SEQ_SEQ = 'to concatenate the sequence';
|
||
En.MIXLY_PYTHON_TEXT_JOIN_SEQ_GET_STR = 'into a string';
|
||
En.MIXLY_PYTHON_TEXT_JOIN_SEQ_TOOLTIP = 'The second parameter must be iterable and each type of iteration is a string; the result returns a string';
|
||
En.MIXLY_PYTHON_TURTLE_EXITONCLICK = 'Set the screen to end the turtle drawing';
|
||
En.MIXLY_MICROPYTHON_SOCKET_CONNECT_TO_ADDRESS = 'Connect to domain name/IP';
|
||
En.MIXLY_ESP32_NETWORK_SOCKET_CONNECT_TOOLTIP = "Connect the socket to a network address";
|
||
En.MIXLY_NETWORK_WIFI_IS_ACTIVE = "Get Active Status";
|
||
En.MIXLY_NETWORK_WIFI_IS_ACTIVE_TOOLTIP = "Get the activation status of the specified network";
|
||
En.MIXLY_ESP32_IOT_ONENET_PRINT_DATA = "Print data";
|
||
En.MIXLY_PYTHON_LOGIC_COMPARE_CONTINOUS_TOOLTIP = "Returns true if the middle term satisfies both left and right inequality, otherwise returns false";
|
||
En.MIXLY_PYTHON_LOGIC_IS = "Yes";
|
||
En.MIXLY_PYTHON_LOGIC_IS_TOOLTIP = "Judge whether the two are the same object, return true if they are the same object, otherwise return false";
|
||
En.MIXLY_PYTHON_INOUT_PRINT_END_TOOLTIP = "Print the specified text, number or other value, ending with the specified content.";
|
||
En.MIXLY_PYTHON_MATH_CONSTANT = "Constant";
|
||
En.MIXLY_PYTHON_MATH_CONSTANT_PI_TOOLTIP = "Approximate PI value (15 digits after decimal point)";
|
||
En.MIXLY_PYTHON_MATH_CONSTANT_E_TOOLTIP = "Approximate value of natural constants (15 decimal places are retained)";
|
||
En.MIXLY_PYTHON_MATH_CONSTANT_PI_MP_TOOLTIP = "Approximate PI value (6 digits after decimal point)";
|
||
En.MIXLY_PYTHON_MATH_CONSTANT_E_MP_TOOLTIP = "Approximate value of natural constants (6 decimal places are retained)";
|
||
En.MIXLY_ESP32_DISPLAY_ANIMATE = "Built-in animation";
|
||
En.MIXLY_PYTHON_LISTS_ZIP_ITEM = "Iterator";
|
||
En.MIXLY_PYTHON_LISTS_ZIP_ITEM_TOOLTIP = 'Drag the iterator into or out of the block on the right to change the number of printed parameters';
|
||
En.MIXLY_PYTHON_LISTS_ZIP = "Packed Iterator";
|
||
En.MIXLY_PYTHON_LISTS_ZIP_TOOLTIP = "Take an iterable object as a parameter, pack the corresponding elements in the object into tuples, and then return a list of these tuples. If the number of elements in each iterator is not consistent, the list Same length as the shortest object ";
|
||
En.blynk_IOT_AUTH = 'Blynk authorization code';
|
||
En.blynk_WIFI_SSID = 'Wi-Fi name';
|
||
En.blynk_WIFI_PASS = 'Wi-Fi password';
|
||
En.blynk_IOT_GET_DATA = 'Get Data from App Virtual Pin';
|
||
En.blynk_IOT_PUSH_DATA = 'Send data to App';
|
||
En.BLYNK_VIRTUALPIN = 'Virtual Pin';
|
||
En.blynk_SERVER_INFO = 'Server Information';
|
||
En.blynk_SERVER_ADD = 'Server Address';
|
||
En.blynk_IOT_DATA_TYPE = 'Data Type';
|
||
En.blynk_IOT_INT = 'Integer';
|
||
En.blynk_IOT_DOUBLE = 'Float';
|
||
En.blynk_IOT_VAR_NAME = 'Variable name';
|
||
En.blynk_TIMER = 'Blynk timer';
|
||
En.blynk_IOT_WidgetLED = 'LED component virtual pin';
|
||
En.blynk_IOT_IR_SEND = 'Infrared controlled air conditioner brand';
|
||
En.blynk_IOT_GREE = 'Gree';
|
||
En.blynk_IOT_MIDEA = 'Beautiful';
|
||
En.blynk_IOT_FAN = 'Supply Air';
|
||
En.blynk_IOT_HEAT = 'Heating';
|
||
En.blynk_IOT_COOL = 'Cooling';
|
||
En.blynk_IOT_DRY = 'Dehumidifying';
|
||
En.blynk_IOT_AUTO = 'Automatic';
|
||
En.blynk_IOT_FAN_3 = 'High speed';
|
||
En.blynk_IOT_FAN_2 = 'Medium speed';
|
||
En.blynk_IOT_FAN_1 = 'Low Speed';
|
||
En.blynk_IOT_IR_FAN = 'Wind speed';
|
||
En.blynk_IOT_IR_TEMP = En.MIXLY_TEMPERATURE;
|
||
En.blynk_IOT_IR_POWER = 'Power';
|
||
En.blynk_IOT_IR_RECEIVE_RAW = 'Infrared signal decoding pin';
|
||
En.blynk_IOT_IR_SEND = 'Infrared Transmit Pin';
|
||
En.blynk_IOT_IR_SEND_TOOLTIP = 'Infrared sending address and content range are integers between 0 and 255';
|
||
En.blynk_IOT_IR_SEND_CODE = 'Encoded Content';
|
||
En.DISPLAY = 'Display';
|
||
En.OLED = 'OLED';
|
||
En.OLEDGET = 'Get OLED';
|
||
En.OLED_CLEAR = 'clear screen';
|
||
En.MIXLY_HEIGHT = 'Height';
|
||
En.MIXLY_WIDTH = 'Width';
|
||
En.OLED_DRAWPIXEL = 'Draw points';
|
||
En.OLED_POSX = 'x coordinate';
|
||
En.OLED_POSY = 'y coordinate';
|
||
En.OLED_PAGE = 'Refresh page';
|
||
En.OLED_DRAWLINE = 'Draw Line';
|
||
En.OLED_START_X = 'Starting x';
|
||
En.OLED_START_Y = 'Starting y';
|
||
En.OLED_END_X = 'Endpoint x';
|
||
En.OLED_END_Y = 'End point y';
|
||
En.OLED_HOR = 'Horizontal';
|
||
En.OLED_VER = 'Vertical';
|
||
En.OLED_LENGTH = 'Length';
|
||
En.OLED_DRAW_TRIANGLE = 'Draw a triangle';
|
||
En.OLED_D0_X = 'A point x';
|
||
En.OLED_D0_Y = 'A point y';
|
||
En.OLED_D1_X = 'B point x';
|
||
En.OLED_D1_Y = 'B point y';
|
||
En.OLED_D2_X = 'C point x';
|
||
En.OLED_D2_Y = 'C point y';
|
||
En.OLED_D3_X = 'D point x';
|
||
En.OLED_D3_Y = 'D point y';
|
||
En.OLED_DRAW_RECTANGLE = 'Draw a rectangle';
|
||
En.OLED_L_U_X = 'Top left corner x';
|
||
En.OLED_L_U_Y = 'Upper left corner y';
|
||
En.OLED_DRAWSTRLINE = 'Draw a line';
|
||
En.OLED_DRAW_RAD_RECTANGLE = 'Draw a rounded rectangle';
|
||
En.OLED_RADIUS = 'Round Corner Radius';
|
||
En.OLED_CIRCLE_RADIUS = 'Radius';
|
||
En.OLED_DRAW_CIRCLE = 'Draw Circle';
|
||
En.OLED_CENTER_CIRCLE_X = 'Circle center x';
|
||
En.OLED_CENTER_CIRCLE_Y = 'Circle center y';
|
||
En.OLED_ELLIPSE_RADIUS_X = 'Radius in the x direction';
|
||
En.OLED_ELLIPSE_RADIUS_Y = 'Radius in y';
|
||
En.OLED_DRAW_ELLIPSE = 'draw Ellipse';
|
||
En.OLED_DRAWSTR = 'display string';
|
||
En.OLED_PRINT_VAR = 'display text';
|
||
En.OLED_STRING = 'Content';
|
||
En.OLED_SET_FONT = 'set font';
|
||
En.oled_draw4Str = 'Display multiple lines of text';
|
||
En.oled_page_tooltip = 'New OLED Page';
|
||
En.oled_setFont_tooltip = 'Set font, small font 11px, medium font 20px, large font 25px';
|
||
En.oled_print_tooltip = 'Print a string variable value. ';
|
||
En.OLED_DRAW_ELLIPSE_TOOLTIP = 'Draw an ellipse, x range (0 ~ 127), y range (0 ~ 63)';
|
||
En.OLED_INIT2 = 'OLED initialization';
|
||
En.OLED_INIT2_TOOLTIP = 'Connect to IIC interface, A4 (SDA), A5 (SCL)';
|
||
En.OLED_SOLID = 'Solid';
|
||
En.OLED_HOLLOW = 'Hollow';
|
||
En.OLED_WHOLE_CICILE = 'Full circle';
|
||
En.OLED_UP_R = 'Upper right';
|
||
En.OLED_UP_L = 'Upper left';
|
||
En.OLED_LOW_R = 'Bottom right';
|
||
En.OLED_LOW_L = 'Lower left';
|
||
En.OLED_BITMAP = 'Display image';
|
||
En.OLED_BITMAP_NAME = 'Image Name';
|
||
En.OLED_BITMAP_DATA = 'Image data';
|
||
En.SAVETO = 'Save to';
|
||
En.MIRROR = 'Mirror';
|
||
En.OLED_GET_HEIGHT_TOOLTIP = 'Get the width or height of the OLED';
|
||
En.OLED_DEF_BMP_DATA_TOOLTIP = 'Set an image name and paste the result of the image / kanji modulus into the image data. ';
|
||
En.OLED_SHOW_BMP_TOOLTIP = 'Set the coordinates of the image / Chinese character to be displayed and its width and height, and then set the image name. ';
|
||
En.OLED_DRAW_PIXE_TOOLTIP = 'Set coordinates to draw points on the OLED. ';
|
||
En.OLED_DRAW_LINE_TOOLTIP = 'Set the start and end coordinates of the line and draw a line. ';
|
||
En.OLED_FONT_chinese1 = 'Songti small font set 1 (411 words)';
|
||
En.OLED_FONT_chinese2 = 'Songti small font set 2 (574 characters)';
|
||
En.OLED_FONT_chinese3 = 'Songti small font set 3 (993 characters)';
|
||
En.OLED_FONT_gb2312a = 'Songti large font set A (4041 words)';
|
||
En.OLED_FONT_gb2312b = 'Songti font set B (4531 words)';
|
||
En.OLED_FONT_gb2312 = 'Complete Song Dynasty (7539 words)';
|
||
En.blynk_EMAIL = 'Send email';
|
||
En.blynk_EMAIL_ADD = 'Email Address';
|
||
En.blynk_EMAIL_SUBJECT = 'Mail subject';
|
||
En.blynk_EMAIL_CONTENT = 'Email content';
|
||
En.blynk_BRIDGE_AUTH = 'Bridge Authorization Code';
|
||
En.blynk_bridge_digitalWrite = 'Bridge digital output';
|
||
En.blynk_bridge_AnaloglWrite = 'Bridge analog output';
|
||
En.BLYNK_BRIDGE_VIRTUALPIN = 'Bridge Virtual Pin';
|
||
En.blynk_WidgetRTC_init = 'RTC component initialization';
|
||
En.blynk_WidgetRTC_setSyncInterval = 'Sync interval';
|
||
En.blynk_WidgetRTC_mintues = 'Minutes';
|
||
En.blynk_WidgetRTC_get_time = 'RTC Component Get';
|
||
En.blynk_iot_playmusic = 'Play music component';
|
||
En.GD5800_MP3 = 'GD5800 MP3 module';
|
||
En.MIXLY_MP3_PLAY = 'Play';
|
||
En.MIXLY_MP3_PAUSE = 'Pause';
|
||
En.MIXLY_MP3_NEXT = 'Next song';
|
||
En.MIXLY_MP3_PREV = 'Previous song';
|
||
En.MIXLY_MP3_VOL_UP = 'Volume up';
|
||
En.MIXLY_MP3_VOL_DOWN = 'Volume Down';
|
||
En.MIXLY_MP3_LOOP_MODE = 'Loop mode';
|
||
En.MIXLY_MP3_LOOP_ALL = 'Loop all';
|
||
En.MIXLY_MP3_LOOP_FOLDER = 'Loop inside the folder';
|
||
En.MIXLY_MP3_LOOP_ONE = 'Single Loop';
|
||
En.MIXLY_MP3_LOOP_RAM = 'Random play';
|
||
En.MIXLY_MP3_EQ_MODE = 'Sound Effect';
|
||
En.MIXLY_MP3_EQ_NORMAL = 'Normal';
|
||
En.MIXLY_MP3_EQ_POP = 'Popular';
|
||
En.MIXLY_MP3_EQ_ROCK = 'Rock';
|
||
En.MIXLY_MP3_EQ_JAZZ = 'Jazz';
|
||
En.MIXLY_MP3_EQ_CLASSIC = 'Classic';
|
||
En.MIXLY_MP3_EQ_BASS = 'Bass';
|
||
En.MIXLY_MP3_VOL = 'Volume';
|
||
En.MIXLY_MP3_PLAY_NUM = 'Playback';
|
||
En.blynk_NOTIFY = 'Send notification';
|
||
En.blynk_USB_SERVER_INFO = 'USB connection mode';
|
||
En.IICSCAN = 'IIC Device Address Lookup';
|
||
En.blynk_smartconfig = 'One Click Network Configuration';
|
||
En.blynk_terminal = 'Terminal component display';
|
||
En.blynk_IOT_terminal_get = 'Get string from terminal';
|
||
En.blynk_VIDEOURL = 'Video Stream';
|
||
En.blynk_LIGHT = 'Light sensor component';
|
||
En.blynk_GRAVITY = 'Gravity sensor component';
|
||
En.blynk_ACC = 'Acceleration sensor component';
|
||
En.blynk_ACC_tooltip = 'Return value range is -9 ~ 9. ';
|
||
En.blynk_time_input_1 = 'Time input component (simple)';
|
||
En.BLYNK_CONNECTED = 'Hardware is connected';
|
||
En.BLYNK_APP_CONNECTED = 'App is connected';
|
||
En.BLYNK_APP_DISCONNECTED = 'App is offline';
|
||
En.BLYNK_syncAll = 'Synchronize all pin states';
|
||
En.blynk_IOT_syncVirtual = 'Sync virtual pin status';
|
||
En.MIXLY_MOTOR_SPEED = 'Speed (-255 ~ 255)';
|
||
En.MIXLY_MOTOR = 'Motor';
|
||
En.MIXLY_MOTOR_SPEED_PIN = 'Speed pin';
|
||
En.MIXLY_MOTOR_DIR_PIN = 'Direction Pin';
|
||
En.MIXLY_HARDWARE = 'Hardware interact';
|
||
En.MIXLY_HARDWARE_SERIAL = 'Serial number';
|
||
En.MIXLY_HARDWARE_START = 'Start interaction';
|
||
En.MixGo_MPU9250 = 'Acceleration sensor';
|
||
En.MIXLY_HANBIT_SHOW_CIRCLE = "Circle center (x %1, y %2) radius %3 %4 padding %5";
|
||
En.MIXLY_HANBIT_SHOW_triangle = "Vertex (x0 %1, y0 %2) (x1 %3, y1 %4) (x2 %5, y2 %6) %7 fills %8";
|
||
En.MIXLY_HANBIT_DRAW_TRIANGLE = "Triangle";
|
||
En.MICROBIT_SENSOR_LIGHT_TOOLTIP = 'Return the value of the light sensor (0 ~ 255)';
|
||
En.MPYTHON_BLYNK_TERMINAL_WIDGET_VPIN_HELPURL = '';
|
||
En.MPYTHON_BLYNK_TERMINAL_WIDGET_VPIN_MESSAGE0 = 'Custom terminal part Terminal virtual pin V %1';
|
||
En.MPYTHON_BLYNK_TERMINAL_WIDGET_VPIN_TOOLTIP = '';
|
||
En.MPYTHON_BLYNK_SYNC_VIRTUAL_HELPURL = '';
|
||
En.MPYTHON_BLYNK_SYNC_VIRTUAL_MESSAGE0 = 'Status of synchronization virtual pin V %1';
|
||
En.MPYTHON_BLYNK_SYNC_VIRTUAL_TOOLTIP = '';
|
||
En.MPYTHON_BLYNK_ON_DISCONNECTED_HELPURL = '';
|
||
En.MPYTHON_BLYNK_ON_DISCONNECTED_MESSAGE0 = 'When Blynk is disconnected';
|
||
En.MPYTHON_BLYNK_ON_DISCONNECTED_TOOLTIP = '';
|
||
En.MPYTHON_BLYNK_ON_CONNECTED_HELPURL = '';
|
||
En.MPYTHON_BLYNK_ON_CONNECTED_MESSAGE0 = 'When Blynk is connected';
|
||
En.MPYTHON_BLYNK_ON_CONNECTED_TOOLTIP = '';
|
||
En.MPYTHON_BLYNKTIMER_RUN_HELPURL = '';
|
||
En.MPYTHON_BLYNKTIMER_RUN_MESSAGE0 = 'Run Blynk timer process';
|
||
En.MPYTHON_BLYNKTIMER_RUN_TOOLTIP = 'Recommended to be placed in \' always repeating \' for loop execution';
|
||
En.MPYTHON_BLYNK_GET_TIMERS_HELPURL = '';
|
||
En.MPYTHON_BLYNK_GET_TIMERS_MESSAGE0 = 'Available Blynk timer';
|
||
En.MPYTHON_BLYNK_GET_TIMERS_TOOLTIP = "";
|
||
En.MPYTHON_BLYNK_STOP_TIMERS_HELPURL = '';
|
||
En.MPYTHON_BLYNK_STOP_TIMERS_MESSAGE0 = 'Stop Blynk timer %1';
|
||
En.MPYTHON_BLYNK_SET_PROPERTY_HELPURL = '';
|
||
En.MPYTHON_BLYNK_SET_PROPERTY_MESSAGE0 = 'Add attribute %1 value %2 to virtual pins';
|
||
En.MPYTHON_BLYNK_SET_PROPERTY_TOOLTIP = "Placed in a read or write event, the virtual pin is determined by the event, and the component bound to this pin will have added attributes";
|
||
En.MPYTHON_BLYNK_EMAIL_HELPURL = '';
|
||
En.MPYTHON_BLYNK_EMAIL_MESSAGE0 = 'Mail to %1 subject %2 body %3';
|
||
En.MPYTHON_BLYNK_EMAIL_TOOLTIP = "";
|
||
En.MPYTHON_BLYNK_RUN_HELPURL = '';
|
||
En.MPYTHON_BLYNK_RUN_MESSAGE0 = 'Run Blynk process';
|
||
En.MPYTHON_BLYNK_RUN_TOOLTIP = 'It is recommended to put it in \' always repeating \' to execute it in a loop';
|
||
En.MPYTHON_BLYNK_APP_NOTIFY_HELPURL = '';
|
||
En.MPYTHON_BLYNK_APP_NOTIFY_MESSAGE0 = 'Blynk App shows notification %1';
|
||
En.MPYTHON_BLYNK_APP_NOTIFY_TOOLTIP = '';
|
||
En.MPYTHON_BLYNKTIMER_HELPURL = '';
|
||
En.MPYTHON_BLYNKTIMER_MESSAGE0 = 'Blynk timer %1 %2 cycle %3 seconds';
|
||
En.MPYTHON_BLYNKTIMER_TOOLTIP = 'Note: \nThe timer serial number is automatically obtained, starting from top to bottom, starting from 0 and continuous, and cannot be "Timer 0, Timer 2". Expose the serial number parameters here for easy viewing! \n Parameters: \n no_timers_err = False-if all timers are stopped, disable exception triggering ';
|
||
En.MPYTHON_BLYNK_SENSOR_DATA_TO_APP_HELPURL = '';
|
||
En.MPYTHON_BLYNK_SENSOR_DATA_TO_APP_MESSAGE0 = "send data %1 to Blynk App\'s virtual pin V %2";
|
||
En.MPYTHON_BLYNK_SENSOR_DATA_TO_APP_TOOLTIP = 'virtual pin: V0 ~ V255';
|
||
En.MPYTHON_BLYNK_SETUP_HELPURL = '';
|
||
En.MPYTHON_BLYNK_SETUP_MESSAGE0 = 'Blynk Settings %1 server %2 port %3 authorization code %4';
|
||
En.MPYTHON_BLYNK_SETUP_TOOLTIP = 'The default server is blynk-cloud.com and the default port is 80';
|
||
En.MPYTHON_BLYNK_APP_DATA_HELPURL = '';
|
||
En.MPYTHON_BLYNK_APP_DATA_MESSAGE0 = 'when received value %2 of virtual pin V %1 from Blynk App';
|
||
En.MIXLY_readTempC = 'Get Centigrade';
|
||
En.MIXLY_readTempF = 'Get Fahrenheit';
|
||
En.MIXLY_MPU6050 = 'MPU6050 Gyroscope';
|
||
En.MIXLY_update_data = 'refresh data';
|
||
En.MIXLY_CHOOSE_AND_GET = 'Select and Get';
|
||
En.MIXLY_CHOOSE_AND_GET_ONE_FILE_NAME = 'single file name';
|
||
En.MIXLY_CHOOSE_AND_GET_MANY_FILE_NAMES = 'multiple file names';
|
||
En.MIXLY_CHOOSE_AND_GET_DIR = 'File Directory';
|
||
En.MIXLY_AipImageClassify = 'Image recognition';
|
||
En.MIXLY_AipFace = 'Face recognition';
|
||
En.MIXLY_AipSpeech = 'Voice Technology';
|
||
|
||
En.MIXLY_AipImageCensor = 'Image Audit';
|
||
En.MIXLY_AipOcr = 'character recognition';
|
||
En.MIXLY_AipNlp = 'Natual language process';
|
||
En.MIXLY_Client = 'Client';
|
||
En.MIXLY_AipSpeech_synthesis = 'speech synthesis';
|
||
En.MIXLY_AIP_ATTR = 'Attribute';
|
||
En.MIXLY_AIP_FUNC = 'Function';
|
||
En.MIXLY_AipSpeech_synthesis_TOOLTIP = 'synthesizes a paragraph of text into speech. The attribute is a dictionary that defaults to empty, including SPD (Speed, 0-9, 5), pit (Tone, 0-9, 5), Vol (Vol, 0-15, 5), per (Pronouncer, 0 is female, 1 is male)';
|
||
En.MIXLY_AipImageClassify_advancedGeneral = 'Universal Object';
|
||
En.MIXLY_AipImageClassify_dishDetect = 'Vegetable Recognition';
|
||
En.MIXLY_AipImageClassify_carDetect = 'Vehicle Recognition';
|
||
En.MIXLY_AipImageClassify_animalDetect = 'Animal Recognition';
|
||
En.MIXLY_AipImageClassify_plantDetect = 'Plant Recognition';
|
||
En.MIXLY_AipImageClassify_logoSearch = 'logo trademark recognition';
|
||
En.MIXLY_AipImageClassify_Image = 'Picture';
|
||
En.MIXLY_AipImageClassify_advancedGeneral_TOOLTIP = 'Recognize the picture, return the data as a dictionary, where result is the result content. ';
|
||
En.MIXLY_AipOcr_basicGeneral = 'Text recognition';
|
||
En.MIXLY_AipOcr_webImage = 'Web Photo Text Recognition';
|
||
En.MIXLY_AipOcr_idcard = 'ID identification';
|
||
En.MIXLY_AipOcr_bankcard = 'bank card identification';
|
||
En.MIXLY_AipOcr_drivingLicense = 'Driver\'s license identification';
|
||
En.MIXLY_AipOcr_vehicleLicense = 'Vehicle License Recognition';
|
||
En.MIXLY_AipOcr_licensePlate = 'License Plate Recognition';
|
||
En.MIXLY_AipOcr_businessLicense = 'Business License Identification';
|
||
En.MIXLY_AipOcr_receipt = 'Universal Bill Recognition';
|
||
En.MIXLY_AipOcr_trainTicket = 'train ticket recognition';
|
||
En.MIXLY_AipOcr_taxiReceipt = 'Taxi Ticket Recognition';
|
||
En.MIXLY_AipOcr_form = 'Form Text Recognition';
|
||
En.MIXLY_AipOcr_vatInvoice = 'Value Added Tax Invoice Recognition';
|
||
En.MIXLY_AipOcr_passport = 'Passport recognition';
|
||
En.MIXLY_AipOcr_handwriting = 'Handwritten character recognition';
|
||
En.MIXLY_AipOcr_TOOLTIP = 'Recognizes text in a given type of picture, returns data as a dictionary, with words_result as the result content. ';
|
||
En.MIXLY_AipSpeech_File = 'Audio File';
|
||
En.MIXLY_AipSpeech_asr = 'Speech Recognition';
|
||
En.MIXLY_AipSpeech_ASR_TOOLTIP = 'Recognition of text in speech. In the attribute dictionary, the key "dev_pid" corresponds to language encoding. 1536 and 1537 are Putonghua, 1737 are English, 1637 are Cantonese and 1837 are Sichuan dialects. The data returned is a dictionary, where result is the result content. ';
|
||
En.MIXLY_AipNlp_lexer = 'Lexical Analysis';
|
||
En.MIXLY_AipNlp_depParser = 'Dependent Parsing';
|
||
En.MIXLY_AipNlp_wordEmbedding = 'vector representation';
|
||
En.MIXLY_AipNlp_dnnlm = 'DNN Language Model';
|
||
En.MIXLY_AipNlp_wordSimEmbedding = 'Semantic Similarity';
|
||
En.MIXLY_AipNlp_simnet = 'short text similarity';
|
||
En.MIXLY_AipNlp_commentTag = 'comment opinion extraction';
|
||
En.MIXLY_AipNlp_sentimentClassify = 'Affective Tendency Analysis';
|
||
En.MIXLY_AipNlp_keyword = 'article label';
|
||
En.MIXLY_AipNlp_topic = 'Article Category';
|
||
En.MIXLY_AipNlp_ecnet = 'text error correction';
|
||
En.MIXLY_AipNlp_emotion = 'conversational emotion recognition';
|
||
En.MIXLY_AipNlp_summary = 'text summary';
|
||
En.MIXLY_AipNlp_TOOLTIP = 'returns data as a dictionary, where items are the result content. ';
|
||
En.MIXLY_AipNlp_Sim = 'Similarity Detection';
|
||
En.MIXLY_AipNlp_Sim_TOOLTIP = 'Returns data as dictionary, where score is the result of similarity. ';
|
||
En.MIXLY_AipNlp_Topic_TOOLTIP = 'The returned data is a dictionary, where item is the result. lv1_tag_list and lv2_tag_list are the first and second classification results, respectively. ';
|
||
En.MIXLY_AipNlp_Summary_TOOLTIP = 'The returned data is a dictionary, where summary is the result. ';
|
||
En.MIXLY_AipNlp_Topic_Title = 'Title';
|
||
En.MIXLY_AipNlp_Topic_Content = 'Body';
|
||
En.MIXLY_AipFace_match = 'Face Match';
|
||
En.MIXLY_AipFace_match_TOOLTIP = 'The returned data is a dictionary, where score is the similarity result. ';
|
||
En.MQTT_publish = 'MQTT: Send message';
|
||
En.MQTT_SERVER = 'MQTT Server';
|
||
En.MQTT_SERVER_ADD = 'Add ';
|
||
En.MQTT_Client_ID = 'Client ID';
|
||
En.MQTT_IOT_ID = 'IOT ID';
|
||
En.MQTT_IOT_PWD = 'IOT PWD';
|
||
En.MQTT_subscribe2 = 'Received';
|
||
En.MQTT_Topic = 'Topic';
|
||
En.MIXLY_MICROBIT_PY_STORAGE_ALL = "read";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_ONE_LINE = "readline";
|
||
En.MIXLY_MICROBIT_PY_STORAGE_ALL_LINES = "readlines";
|
||
En.MIXLY_ENCODER = 'Encoder';
|
||
En.MIXLY_SIMPLE_TIMER = 'Simple Timer';
|
||
En.MIXLY_PYTHON_STORAGE_OPEN_FILE_WITH_OS = 'open file with default program';
|
||
En.DS_CREATE_LINKEDLIST_CONTAINER_TOOLTIP = "";
|
||
En.DS_CREATE_LINKEDLIST_CONTAINER_TOOLTIP = "Add, delete, or rearrange sections to reconfigure the properties of this node.";
|
||
En.DS_CREATE_LINKEDLIST_ITEM_TITLE = "Attributes"
|
||
En.DS_CREATE_LINKEDLIST_ITEM_TOOLTIP = "";
|
||
En.DS_CREATE_LINKEDLIST_NEW = "Create list";
|
||
En.DS_CREATE_LINKEDLIST_HEAD = "Head node name";
|
||
En.DS_CREATE_LINKEDLIST_TYPE = "Node Type ";
|
||
En.DS_CREATE_LINKEDLIST_ATTRIBUTE = "Built-in attributes and corresponding values";
|
||
En.DS_CREATE_LINKEDLIST_TOOLTIP = "Create a linked list head node, the node type is the defined class, the attribute is the attribute of the class, and the head node is the object defined using the class."
|
||
En.DS_CREATE_NODE_USE = "Use existing node type";
|
||
En.DS_CREATE_NODE_NEW = "Define a new node";
|
||
En.DS_CREATE_NODE_TOOLTIP = "Create a new object node with a defined class.";
|
||
En.DS_GET_NODE_ATTR_NODE = "Get Node";
|
||
En.DS_SET_NODE_ATTR_NODE = "Node";
|
||
En.DS_SET_NODE_ATTR_SET = "The corresponding value is set to";
|
||
En.DS_GET_NODE_ATTR_TOOLTIP = "Get the corresponding value of an attribute of a node (an object).";
|
||
En.DS_SET_NODE_ATTR_TOOLTIP = "Modify the corresponding value of an attribute of a node (an object).";
|
||
En.DS_ADD_NODE_HEAD_NODE = "Node head";
|
||
En.DS_ADD_NODE_LINKEDLIST = "add linklist";
|
||
En.DS_ADD_NODE_BEFORE = "before";
|
||
En.DS_ADD_NODE_AFTER = "after";
|
||
En.DS_ADD_NODE = "insert";
|
||
En.DS_ADD_NODE_TOOLTIP = "Insert a new node at the specified position in the linked list, and print the result of whether the inserted node is successful.";
|
||
En.DS_ADD_NODE_ATTR = "linklist node";
|
||
En.DS_DEL_NODE_NAME = "Delete node";
|
||
En.DS_DEL_NODE_ATTR = "Delete attr";
|
||
En.DS_DEL_NODE_TOOLTIP = "Delete the node at the specified position in the linked list, and print the result of whether the deleted node was successful.";
|
||
En.DS_REVERSE_LINKEDLIST = "Transposed List";
|
||
En.DS_REVERSE_LINKEDLIST_NEW_HEAD = "New header node name";
|
||
En.MIXPY_SERIAL_OPEN = "open avaible serial";
|
||
En.MIXPY_SERIAL_OPEN_TIMEOUT = "Read wait time (seconds)";
|
||
En.MIXPY_SERIAL_OPEN_TOOLTIP = "Open the available serial port, the read wait time is the time to wait when there is no response when reading data from the serial port";
|
||
En.MIXPY_SERIAL_WRITE = "Serial Printing";
|
||
En.MIXPY_SERIAL_WRITE_TOOLTIP = "Send data to the available serial port, the data type is string, ending with \\r";
|
||
En.MIXPY_SERIAL_READ = "The length of the serial port read data is";
|
||
En.MIXPY_SERIAL_READ_TOOLTIP = "Read data of the specified length from the available serial port";
|
||
En.MIXPY_SERIAL_CLOSE = "Close the serial port";
|
||
En.MIXPY_SERIAL_CLOSE_TOOLTIP = "Close the serial port and end the data interaction with the serial port";
|
||
En.MIXPY_TEXT_ENCODE = "encode";
|
||
En.MIXPY_TEXT_DECODE = "decode";
|
||
En.MIXPY_TEXT_ENCODE_DECODE_TOOLTIP = "";
|
||
En.MIXPY_AI_AUDIO = "Record audio with a microphone, File name";
|
||
En.MIXPY_AI_AUDIO_TIME = "Recording duration (seconds)";
|
||
En.MIXPY_AI_AUDIO_TOOLTIP = "To record audio of a specified duration, the file name must specify the format and storage path of the recording file";
|
||
En.MIXPY_AI_PHOTO = "Take photo with camera filename";
|
||
En.MIXPY_AI_PHOTO_BUTTON = "Shoot button";
|
||
En.MIXPY_AI_PHOTO_TOOLTIP = "Take photo with camera, do not include Chinese path in file name";
|
||
En.MIXPY_AI_RESULT = "Get results";
|
||
En.blynk_AP_config = 'Smart Config Wi-Fi(AP Mode)';
|
||
En.blynk_AP_config_tooltip = 'It will create a Wi-Fi if disconnect to Wi-Fi';
|
||
En.blynk_AP_config2 = 'Smart Config Wi-Fi & Blynk Auth(AP Mode)';
|
||
En.Blynk_connect_state = "Blynk connect state";
|
||
En.Blynk_connected_Tooltip = 'if OK,return 1,esle return 0';
|
||
En.blynk_terminal_clear = 'Blynk Terminal Clear';
|
||
En.blynk_lcd = 'LCD Widget Display';
|
||
En.blynk_esp32_ble = 'Blynk BLE Connection';
|
||
En.blynk_esp32_Bluetooth = 'Blynk Bluetooth Connection';
|
||
En.get_array2_value = 'Get Two-dimensional array Value';
|
||
En.array2_assignment = 'Two-dimensional array assignment';
|
||
En.array2_rows = 'rows';
|
||
En.array2_cols = 'cols';
|
||
En.MIXLY_ARRAY2 = 'Two-dimensional array Name';
|
||
En.HTML_DOCUMENT = "HTML Document";
|
||
En.HTML_LEVEL = "h";
|
||
En.HTML_HEAD = "head";
|
||
En.HTML_BODY = "body";
|
||
En.HTML_TABLE = "table";
|
||
En.HTML_LINE = "tr";
|
||
En.HTML_CELL = "td";
|
||
En.HTML_OL = "ol";
|
||
En.HTML_UL = "ul";
|
||
En.HTML_LI = "li";
|
||
En.HTML_SPAN = "span";
|
||
En.HTML_P = "p";
|
||
En.HTML_FORM = "form";
|
||
En.HTML_STYLE = "style";
|
||
En.HTML_TEXT = "text";
|
||
En.HTML_EMAIL = "email";
|
||
En.HTML_NUMBER = "number";
|
||
En.HTML_PASSWORD = "password";
|
||
En.HTML_CHECKBOX = "checkbox";
|
||
En.HTML_RADIOBUTTON = "radiobutton";
|
||
En.HTML_BUTTON = "button";
|
||
En.HTML_COLOUR = "colour";
|
||
En.HTML_DATE = "date";
|
||
En.HTML_LOCALTIME = "local time";
|
||
En.HTML_FILE = "file";
|
||
En.HTML_HIDDEN = "hidden";
|
||
En.HTML_IMAGE = "image";
|
||
En.HTML_MONTH = "month";
|
||
En.HTML_RANGE = "range";
|
||
En.HTML_SEARCH = "search";
|
||
En.HTML_SUBMIT = "submit";
|
||
En.HTML_TELEPHONENUMBER = "telephone number";
|
||
En.HTML_TIME = "time";
|
||
En.HTML_URL = "url";
|
||
En.HTML_WEEK = "week";
|
||
En.HTML_NAME = "name";
|
||
En.HTML_VALUE = "value";
|
||
En.HTML_FORM_CONTENT = "Form item";
|
||
En.NTP_SERVER = 'NTP Time Server';
|
||
En.MIXLY_TimeZone = 'TimeZone';
|
||
En.NTP_server_get_time = 'NTP Get';
|
||
En.MIXLY_CLICK = 'Click';
|
||
En.MIXLY_DOUBLE_CLICK = 'Double Click';
|
||
En.MIXLY_LONG_PRESS_START = 'Long Press Start';
|
||
En.MIXLY_DURING_LONG_PRESS = 'During Long Press';
|
||
En.MIXLY_LONG_PRESS_END = 'Long Press End';
|
||
En.ONEBUTTON = 'Multifunctional Button';
|
||
En.PS2 = 'PS2 handle';
|
||
En.PS2_TRIANGLE = 'Triangle';
|
||
En.PS2_CIRCLE = 'Circle';
|
||
En.PS2_CROSS = 'Cross';
|
||
En.PS2_SQUARE = 'Square';
|
||
En.PS2_L1 = 'Left 1';
|
||
En.PS2_L2 = 'Left 2';
|
||
En.PS2_L3 = 'Left 3';
|
||
En.PS2_R1 = 'Right 1';
|
||
En.PS2_R2 = 'Right 2';
|
||
En.PS2_R3 = 'Right 3';
|
||
En.PS2_UP = 'Up';
|
||
En.PS2_DOWN = 'Down';
|
||
En.PS2_LEFT = 'Left';
|
||
En.PS2_RIGHT = 'Right';
|
||
En.PS2_SELECT = 'Select';
|
||
En.PS2_START = 'Start';
|
||
En.PS2_RX = 'Right X';
|
||
En.PS2_RY = 'Right Y';
|
||
En.PS2_LX = 'Left X';
|
||
En.PS2_LY = 'Left Y';
|
||
En.PS2_stick = 'PS2 Joystick';
|
||
En.PS2_BUTTON = 'PS2 Button';
|
||
En.PS2_setRumble = 'setRumble';
|
||
En.arduino_blynk_bluetooth = 'Bluetooth Connection';
|
||
En.blynk_table = 'Table add Data';
|
||
En.blynk_table_update = 'Table update data';
|
||
En.blynk_table_select = 'Table select';
|
||
En.blynk_table_highlight = 'Table Highlight';
|
||
En.blynk_table_unselect = 'Table cancel selection';
|
||
En.blynk_table_cleardata = 'Table Clear Data';
|
||
En.blynk_connected = 'Connection state';
|
||
En.HX711_offset = 'Offset';
|
||
En.HX711_scale = 'Scale';
|
||
En.Handbit = 'HandBit';
|
||
En.HANDBIT_FORWARD = 'Forward';
|
||
En.HANDBIT_BACKWARD = 'Backward';
|
||
En.HANDBIT_LEFT = 'Left';
|
||
En.HANDBIT_RIGHT = 'Right';
|
||
En.HANDBIT_UP = 'Up';
|
||
En.HANDBIT_DOWN = 'Down';
|
||
En.BME280 = 'Read BME280';
|
||
En.ESP32_HALL = 'ESP32 Hall';
|
||
En.ESP32_TEMP = 'ESP32 Temperature';
|
||
En.MIXLY_BACKGROUND_COLOR = 'Background Color';
|
||
En.MIXEPI = 'MixePi';
|
||
En.DATA_TYPE_CONVERSION = 'Data type conversion';
|
||
En.TEXT_TO = 'to';
|
||
En.STRING_VARIABLE = 'String variable';
|
||
En.TEXT_KEEP = 'Reserved';
|
||
En.TEXT_DECIMAL = 'Valid value';
|
||
En.SUBSTRING_HELP = 'Intercepting a string such as substring to intercept 0-3 returns sub';
|
||
En.DECIMAL_PLACES_HELP = 'The decimal is rounded off to get the valid bit, for example, 6.66666 retains 2 digits to 6.67';
|
||
En.LETTER_CONVERSION_HELP = 'String variables are converted to uppercase and lowercase, string variables are assigned to string case-converted values';
|
||
En.DATA_REPLACEMENT_HELP = 'String variable part data replacement, string variable is assigned to the value after string replacement';
|
||
En.ELIMINATE_HELP = 'It is useful when you know that there are unrelated whitespace characters at the beginning or end of a String and you want to eliminate them. A space is a character that takes up space but is not seen. It includes a single space';
|
||
En.FIRST_AND_LAST_HELP = 'Returns whether to start or end with a specific string';
|
||
En.TYPE_CONVERSION_HELP = 'Convert a variable to the corresponding type value.';
|
||
En.STARTSWITH = 'beginning';
|
||
En.ENDSWITH = 'end';
|
||
En.ELIMINATE_NON_VISUAL_CHARACTERS = 'Eliminate non-visual characters';
|
||
En.LETTERS_ARE_CONVERTED_TO = 'Letters are converted to';
|
||
En.REPLACE_WITH = 'Replace with';
|
||
En.AS_A_STRING = 'As a string';
|
||
En.CAPITAL = 'capital';
|
||
En.LOWER_CASE = 'lower case';
|
||
En.DUALL_CORE_MULTITASKING = 'ESP32 Dual-core multitasking';
|
||
En.CORE_PRIORITY1 = 'Core 1 priority';
|
||
En.CORE_PRIORITY2 = 'Core 2 priority';
|
||
En.DUALL_CORE_MULTITASKING_HELP = 'ESP32 dual-core multi-tasking, processing two tasks at the same time does not interfere with each other, the priority is up to 3 (if the watchdog is triggered, you need to add a delay function only for dual-core multi-task, the delay time should not affect the execution of other functions)';
|
||
En.FOLDING_BLOCK = 'Folding block please describe the function here';
|
||
En.FOLDING_BLOCK_HELP = 'Reading is very headache when using too many blocks, the code block put into it will not change, just used as a shell, why not? You know ^.^ very convenient';
|
||
En.OLED_ICON = 'Icon';
|
||
En.TCS34725_Get_RGB = 'TCS347255 Sensor Get Color';
|
||
En.set_EN_Font = 'English Font';
|
||
En.set_CN_Font = 'Chinese Font';
|
||
En.FontSize = 'Font Size';
|
||
En.Font_Style = 'Font Style';
|
||
En.esp_camera = 'ESP32 CAM camera, after uploading the program, open the camera address browser through the serial port monitor (default baud rate 115200)';
|
||
En.MIXLY_RESOLUTION = 'resolution';
|
||
En.inout_esp32_dac = "DAC output pin;";
|
||
En.take_a_photo1 = 'ESP32 CAM photo';
|
||
En.super_delay_function = 'Registration delay function';
|
||
En.execute_super_delay_function = 'Execution delay function';
|
||
En.time_interval = 'Time interval (ms)';
|
||
En.number_of_executions = 'Number of executions';
|
||
En.super_delay_function_help = 'Register a function that requires a delayed execution';
|
||
En.execute_super_delay_function_help = 'Execute the delay function, set the delay time and the number of executions';
|
||
En.MIXLY_SERVO_WRITEMICROSECONDS = 'write microseconds';
|
||
En.MIXLY_Z_AXIS = 'z-axis';
|
||
En.MIXLY_SELFADD = "self add";
|
||
En.MIXLY_SELFSUB = "self sub";
|
||
En.MIXLY_SELFMULT = "self mult";
|
||
En.MIXLY_SELFDIVI = "self divi";
|
||
En.MIXLY_SD_FILE_Exist = 'File Exist?';
|
||
En.MIXPY_DATA_ARRAY_CREATE_FROM = "first item;";
|
||
En.MIXPY_DATA_ARRAY_CREATE_TO = "last item;";
|
||
En.MIXLY_ATTATCH = 'attach';
|
||
En.MIXLY_DETACH = 'detach';
|
||
En.OLED_TYPE_SSD1306 = '0.96 inch SSD1306';
|
||
En.OLED_TYPE_SH1106 = '1.3 inch SH1106';
|
||
En.MOTOR_HR8833 = 'HR8833 Motor';
|
||
En.MOTOR_HR8833_TEAM_NO = 'Group NO.';
|
||
En.MIXLY_I2C_REGADD = "Register address";
|
||
En.MIXLY_Keypad = '4*4 Matrix keyboard';
|
||
En.MIXLY_Keypad_define = 'Define keyboard';
|
||
En.MIXLY_Keypad_GETKEY = 'get key value';
|
||
En.MIXLY_Keypad_GETKEY = 'get key value';
|
||
En.MIXLY_DEVICE = 'device';
|
||
En.MIXLY_MASTER = "master";
|
||
En.MIXLY_SALVE = "salve";
|
||
En.MIXLY_SEND_DATA = "send data";
|
||
En.MIXLY_RETURN_DATA = "return value";
|
||
En.TFT_Brightness = "Backlight";
|
||
En.BLYNK_DISCONNECTED = "hardware is disconnected;";
|
||
En.MIXLY_U8G2_SETCONTRAST_HELP = "OLED backlight brightness range (0-255)";
|
||
En.MIXLY_DHT11_T = En.MIXLY_TEMPERATURE;
|
||
En.MIXLY_DHT11_H = En.MIXLY_Humidity;
|
||
En.MIXLY_LCD_STAT_ON = En.MIXLY_ON;
|
||
En.MIXLY_LCD_STAT_OFF = En.MIXLY_OFF;
|
||
En.MIXGO_ONBOARDDISPLAY_HELP = "When the hardware of mixgo Max uses the on-board display module, it needs to connect the display to pin 21 and pin 22";
|
||
En.MIXLY_ELECLEVEL = "Level trigger";
|
||
En.MIXLY_GET_PRESSES_TIME = "during (seconds)";
|
||
En.MIXLY_PYTHON_LOGIC_IS_NOT = "is not";
|
||
En.MIXLY_PYTHON_LOGIC_IS_NOT_IN = "is not in";
|
||
En.MATH_DEC_MODE = "mode";
|
||
En.REQUEST_SUCCEEDED = "Request failed";
|
||
En.REQUEST_FAILED = "Request succeeded";
|
||
En.RIGHT_CYCLE = "Right cycle";
|
||
En.LEFT_CYCLE = "Left cycle";
|
||
En.MIXLY_FAILED = "Failed";
|
||
En.MIXLY_SUCCESS = "Success";
|
||
En.MIXLY_WRITE = "Write";
|
||
En.MIXLY_READONLY = "read only";
|
||
En.MIXLY_FILE_PATH = "File Path";
|
||
En.GET_THE_DIFFERENCE_BETWEEN_TWO_DATES = 'Get the difference between two dates';
|
||
En.START = 'start ';
|
||
En.END = 'end ';
|
||
En.MLX90614_TYPE = 'Infrared temperature sensor';
|
||
En.MLX90614_TARGET_OBJECT_TEMP = 'Target object temperature';
|
||
En.MLX90614_AMBIENT_TEMP = 'Ambient temperature';
|
||
En.IR_AND_TONE_WARNING = 'Warning:\n' + 'The buzzer module and the infrared receiving module cannot be used at the same time.\n' + 'Please consider using a buzzer module (no timer) or removing the infrared receiving module';
|
||
En.USE_SERIAL_PORT = 'Use serial port';
|
||
En.DFPLAYER_MINI_SET_TIMEOUT = "Serial communication timeout is set to";
|
||
En.DFPLAYER_MINI_SET_TIMEOUT_TOOLTIP = "DFPlayer Mini sets the timeout for serial communication";
|
||
En.DFPLAYER_MINI_SET_VOLUME = "Volume is set to";
|
||
En.DFPLAYER_MINI_SET_VOLUME_TOOLTIP = "DFPlayer Mini Set the volume, the range is 0 ~ 30";
|
||
En.DFPLAYER_MINI_VOLUME_UP_DOWN_TOOLTIP = "DFPlayer Mini volume + or -";
|
||
En.DFPLAYER_MINI_SET_EQ = " Sound effect set";
|
||
En.DFPLAYER_MINI_SET_EQ_TOOLTIP = "DFPlayer Mini settings";
|
||
En.DFPLAYER_MINI_SET_OUTPUTDEVICE = "Set the playback device to";
|
||
En.DFPLAYER_MINI_SET_OUTPUTDEVICE_TOOLTIP = "DFPlayer Mini designated playback device";
|
||
En.DFPLAYER_MINI_STOP_ADVERTISE = "Stop interruption";
|
||
En.DFPLAYER_MINI_ENABLE_LOOP = "Loop playback starts";
|
||
En.DFPLAYER_MINI_DISABLE_LOOP = "Loop playback stops";
|
||
En.DFPLAYER_MINI_ENABLE_LOOP_ALL = "Loop all tracks";
|
||
En.DFPLAYER_MINI_DISABLE_LOOP_ALL = "Stop looping tracks";
|
||
En.DFPLAYER_MINI_RANDOM_ALL = "Shuffle all tracks";
|
||
En.DFPLAYER_MINI_ENABLE_DAC = "Turn on audio output";
|
||
En.DFPLAYER_MINI_DISABLE_DAC = "Turn off audio output";
|
||
En.DFPLAYER_MINI_SLEEP = "Go to sleep";
|
||
En.DFPLAYER_MINI_ADVERTISE = "Insert";
|
||
En.DFPLAYER_MINI_PLAYMP3FOLDER = "Play MP3 folder";
|
||
En.DFPLAYER_MINI_SONG = "Track";
|
||
En.DFPLAYER_MINI_PLAY_LOOP_TOOLTIP = "DFPlayer Mini plays, loops, and inserts specified tracks";
|
||
En.DFPLAYER_MINI_PLAY_ADVERTISE_TOOLTIP = "DFPlayer Mini inserts the specified track, file name (0 ~ 65535)";
|
||
En.DFPLAYER_MINI_PLAY_PLAYMP3FOLDER_TOOLTIP = "DFPlayer Mini plays the specified track in the MP3 folder with the file name (0 ~ 65535)";
|
||
En.DFPLAYER_MINI_FOLDER = "Under the folder";
|
||
En.DFPLAYER_MINI_LARGEFOLDER = "Under big folder";
|
||
En.DFPLAYER_MINI_PLAY_PLAYFOLDER_TOOLTIP = "DFPlayer Mini plays the tracks in the specified folder, folder name (1 ~ 99), file name (1 ~ 255)";
|
||
En.DFPLAYER_MINI_PLAY_PLAYLARGEFOLDER_TOOLTIP = "DFPlayer Mini plays the tracks in the specified large folder, folder name (1 ~ 10), file name (1 ~ 1000)";
|
||
En.DFPLAYER_MINI_LOOP_FOLDER = "Loop folder";
|
||
En.DFPLAYER_MINI_LOOP_FOLDER_TOOLTIP = "DFPlayer Mini loops tracks in a specified folder";
|
||
En.DFPLAYER_MINI_READ_NOW_DATA_TOOLTIP = "DFPlayer Mini Gets the current status, current volume, current sound effect, and the type of the returned data is int";
|
||
En.DFPLAYER_MINI_READ_FILE_COUNTS = "Total number of files";
|
||
En.DFPLAYER_MINI_READ_CURRENT_FILE_NUMBER = "Current track number";
|
||
En.DFPLAYER_MINI_READ_FILE_COUNTS_TOOLTIP = "DFPlayer Mini Gets the total number of files or the current track of U disk, SD card, FLASH, and the type of returned data is int";
|
||
En.DFPLAYER_MINI_READ_FILE_COUNTS_INFOLDER_TOOLTIP = "DFPlayer Mini gets the number of files in the specified folder, and the type of the returned data is int";
|
||
En.DFPLAYER_MINI_AVAILABLE_TOOLTIP = "myDFPlayer.available (), the type of the returned data is boolean";
|
||
En.DFPLAYER_MINI_READ_TYPE_TOOLTIP = "myDFPlayer.readType (), the type of the returned data is uint8_t";
|
||
En.DFPLAYER_MINI_READ_TOOLTIP = "myDFPlayer.read (), the type of the returned data is uint16_t";
|
||
En.YX5200_MP3 = 'Mini MP3 module';
|
||
En.RETURN_DATA_ANALYSIS = "Return data analysis";
|
||
En.LCD_NUMBERING = 'Numbering';
|
||
En.COLUMN_DISPLAY_IMAGE = 'Column display image';
|
||
En.SCOOPTASK_WARNING = "Warning: \nThe number of the SCoopTask module cannot be duplicated, \nplease consider modifying the number of this module or deleting this module.";
|
||
En.BLYNK_TABLE_ORDER = 'Table click';
|
||
En.BLYNK_TABLE_CLICK = "Table order";
|
||
En.SKLEARN_CLASSIFICATION_GENERATION = "sklearn classification sample generation";
|
||
En.NUMBER_OF_SAMPLES = "Number of samples";
|
||
En.NUMBER_OF_FEATURES = "Number of features";
|
||
En.NUMBER_OF_EFFECTIVE_FEATURES = "Number of effective features";
|
||
En.NUMBER_OF_REDUNDANT_FEATURES = "Number of redundant features";
|
||
En.NUMBER_OF_REPEATED_FEATURES = "Number of repeated features";
|
||
En.NUMBER_OF_CLASSES = "Number of classes";
|
||
En.NUMBER_OF_CLUSTERS_PER_CLASSES = "Number of clusters per class";
|
||
En.NUMBER_OF_LABELS = "Number of labels";
|
||
En.NUMBER_OF_CLUSTERS = "Number of clusters/cluster center coordinates";
|
||
En.RANDOM_SEED = "Pseudo-random seed";
|
||
En.SKLEARN_REGRESSION_GENERATION = "sklearn regression sample generation";
|
||
En.DEVIATION = "deviation";
|
||
En.NOISE = "noise";
|
||
En.SKLEARN_CLUSTERING_GENERATION = "sklearn clustering sample generation";
|
||
En.STANDARD_DEVIATION_OF_CLUSTER = "Standard deviation of cluster";
|
||
En.CLUSTER_BOUNDING_BOX = "Cluster bounding box";
|
||
En.SHUFFLE_SAMPLES = "Shuffle samples";
|
||
En.LOAD = "load";
|
||
En.SKLEARN_LOAD_IRIS = "Iris dataset";
|
||
En.SKLEARN_LOAD_BOSTON = "Boston house price data set";
|
||
En.SKLEARN_LOAD_DIABETES = "Diabetes data set";
|
||
En.SKLEARN_LOAD_BREAST_CANCER = "Breast cancer data set";
|
||
En.SKLEARN_LOAD_LINNERUD = "Fitness training data set";
|
||
En.SKLEARN_LOAD_DIGITS = "Handwritten digital data set";
|
||
En.DATA_SET = "data set";
|
||
En.EIGENVALUES = "Eigenvalues";
|
||
En.LABEL_VALUE = "Label value";
|
||
En.FEATURE = "feature";
|
||
En.DATA_SEGMENTATION = "Data segmentation";
|
||
En.TEST_SET_PROPORTION = "Test set proportion";
|
||
En.SKLEARN_LINEARREGRESSION_INIT = "Initialize linear regression algorithm";
|
||
En.SKLEARN_RIDGE_INIT = "Initialized Ridge Regression Algorithm";
|
||
En.SKLEARN_DECISIONTREE_INIT = "Initialize decision tree";
|
||
En.SKLEARN_RANDOMFOREST_INIT = "Initialize random forest";
|
||
En.SKLEARN_KNN_INIT = "Initialize K nearest neighbors";
|
||
En.SKLEARN_GAUSSINNB_INIT = "Initialized Gaussian Bayesian classification algorithm";
|
||
En.SKLEARN_KMEANS_INIT = "Initial K-means clustering algorithm";
|
||
En.MODEL_NAME = "Model name";
|
||
En.SKLEARN_CALCULATE_MODEL_INTERRUPT = "Calculate model intercept";
|
||
En.SKLEARN_REGRESSION_NORMIALIZATION = "Regression normalization";
|
||
En.SKLEARN_THREADS = "Threads";
|
||
En.SKLEARN_REGULA_INTENSITY = "Regular intensity";
|
||
En.SKLEARN_MAX_ITER = "Maximum number of iterations";
|
||
En.SKLEARN_CLASSIFICATION_ALGORITHM = "Classification algorithm";
|
||
En.SKLEARN_REGRESSION_ALGORITHM = "Regression algorithm";
|
||
En.SKLEARN_MAXIMUM_TREE_DEPTH = "Maximum tree depth";
|
||
En.NUMBER_OF_TREES = "Number of trees";
|
||
En.NUMBER_OF_CLUSTERS_JUST = "Number of clusters";
|
||
En.TRAINING_MODEL = "Training model";
|
||
En.MODEL_PRODICTION = "Model prediction";
|
||
En.CALCULATE_THE_SCORE = "Calculate the score";
|
||
En.SKLEARN_GENERALIZED_LINEAR_REGRESSION = "Generalized linear regression";
|
||
En.SKLEARN_COEF = "Weights";
|
||
En.SKLEARN_INTERCEPT = "Bias";
|
||
En.SKLEARN_CLUSTERING = "Clustering";
|
||
En.SKLEARN_CLUSTER_CENTER = "Cluster center coordinates";
|
||
En.SKLEARN_LABELS_AFTER_CLUSTERING = "Label after clustering";
|
||
En.SKLEARN_CLUSTERING_SUM_OF_SQUARED_DISTANCES = "Sum of squared distances";
|
||
En.SKLEARN_SAVE_MODEL = "Save the model";
|
||
En.SKLEARN_LOAD_MODEL = "Load the model";
|
||
En.MATH_ROUND = 'rounding';
|
||
En.MATH_ROUND_NEW_TOOLTIP = 'Rounds a number to the number of digits specified after the decimal point is retained';
|
||
En.PY_STORAGE_FILE_OBJECT = ", and return the file object";
|
||
En.COLOUR_RGB_ORANGE = "orange";
|
||
En.COLOUR_RGB_YELLOW = "yellow";
|
||
En.COLOUR_RGB_CYAN = "cyan";
|
||
En.COLOUR_RGB_PURPLE = "purple";
|
||
En.COLOUR_RGB_WHITE = "white";
|
||
En.CLOCKWISE = "clockwise";
|
||
En.ANTI_CLOCKWISE = "anti_clockwise";
|
||
En.CREATE_CLASS = "Create Class";
|
||
En.FATHER_CLASS = "Father";
|
||
En.MIXPY_CLASS = "Class";
|
||
En.MIXPY_ATTRIBUTE_OF = "Attribute of";
|
||
En.MIXPY_CREATE_METHOD = "Create method";
|
||
En.MIXPY_EXECUTION_METHOD = "Execution method";
|
||
En.MIXPY_OBJECT = "Object";
|
||
En.MIXPY_ADD_PARAMETERS = "Add parameters";
|
||
En.PYTHON_RANGE_STEP = "range";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOTEXT = "convert a value to a string.";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOINT = "convert a value to an integer.";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOFLOAT = "convert a value to a floating-point number.";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOBOOL = "convert a value to a Boolean value.";
|
||
En.MIXLY_TOBOOL = "to boolean";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOLIST = "convert a value to a list.";
|
||
En.MIXLY_TOLIST = "to list";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOTUPLE = "convert a value to a tuple.";
|
||
En.MIXLY_TOTUPLE = "to tuple";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOSET = "convert a value to a set.";
|
||
En.MIXLY_TOSET = "to set";
|
||
En.MIXLY_PYTHON_TOOLTIP_TODICT = "convert a value to a dictionary.";
|
||
En.MIXLY_TODICT = "to dictionary";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOARRAY = 'Convert a value to an array.';
|
||
En.MIXLY_TOARRAY = 'Turn array';
|
||
En.MIXLY_PYTHON_PASS = 'pass';
|
||
En.MIXLY_PYTHON_TRY = 'try';
|
||
En.MIXLY_PYTHON_EXCEPT = 'except';
|
||
En.MIXLY_PYTHON_FINALLY = 'finally';
|
||
En.MIXLY_SOFT_ANALOGWRITE_PIN = 'Software analog output pin #';
|
||
En.MIXLY_CANCEL_SOFT_ANALOGWRITE_PIN = 'Cancel software analog output pin #';
|
||
En.MIXLY_TOOLTIP_CANCEL_SOFT_ANALOGWRITE_PIN = 'Cancel the software simulation PWM of the specified pin';
|
||
En.MIXLY_MITHON_NEAR = "is worked";
|
||
En.MIXLY_STM32_OLED_SET_CURSOR_POSITION = "Cursor position is set to";
|
||
En.MIXLY_STM32_OLED_TINY = "extremely small";
|
||
En.MIXLY_STM32_OLED_SMALL = "small";
|
||
En.MIXLY_STM32_OLED_BIG = "big";
|
||
En.MIXLY_STM32_OLED_HUGE = "huge";
|
||
En.MIXLY_STM32_OLED_SET_FONT_COLOR = "Set font color";
|
||
En.MIXLY_STM32_OLED_BLACK_ON_WHITE = "Black on white";
|
||
En.MIXLY_STM32_I2C_SLAVE_SEND_ARRAY = "Slave send array";
|
||
En.MIXLY_STM32_I2C_SLAVE_SEND_EVENT = "Slave send event";
|
||
En.MIXLY_STM32_I2C_SLAVE_RECEIVE_EVENT = "Receive events from the machine";
|
||
En.MIXLY_STM32_I2C_SLAVE_SEND_BYTE = "Slave send byte";
|
||
En.MIXLY_STM32_SPI_GET_REGISTER_DATA = "Get register data";
|
||
En.MIXLY_STM32_SPI_DATA_RECEIVED = "Data received";
|
||
En.MIXLY_GLOBAL_VARIABLE = "Global variable";
|
||
En.MIXLY_LOCAL_VARIABLE = "Local variable";
|
||
En.MIXLY_TYPE = "Type";
|
||
En.MIXLY_volume = "Volume";
|
||
En.MIXLY_SD_LIST_FILES = "List Files in SD Root";
|
||
En.MIXLY_SD_clusterCount = "Cluster Count";
|
||
En.MIXLY_SD_blocksPerCluster = "Blocks Per Cluster";
|
||
En.MIXLY_SD_TOTAL_blocks = "Total blocks";
|
||
En.MIXLY_PRINT_INLINE = "in line";
|
||
En.MIXLY_STM32_TFT_GREENTAB = "Green label";
|
||
En.MIXLY_STM32_TFT_REDTAB = "Red label";
|
||
En.MIXLY_STM32_TFT_BLACKTAB = "Black label";
|
||
En.MIXLY_STM32_TFT_FONT_COLOR = "font color";
|
||
En.MIXLY_STM32_TFT_BACKGROUND_COLOR = "background color";
|
||
En.MIXLY_STM32_TFT_BACKGROUND = "background";
|
||
En.MIXLY_STM32_TFT_SIZE = "size";
|
||
En.MIXLY_TOOLTIP_STORE_EEPROM_PUT = 'Write any type of data to EEPROM specific address';
|
||
En.MIXLY_TOOLTIP_STORE_EEPROM_GET = 'Read any type of data from a specific address of EEPROM';
|
||
En.MIXLY_WIFI_LINK_DEVICE = 'Link device';
|
||
En.MIXLY_STM32_SPI_REMAP = 'Remap';
|
||
En.MIXLY_RFID_READ_CARD_UID = 'Read card number';
|
||
En.MIXLY_RFID_WRITE_CARD = 'Write card';
|
||
En.MIXLY_RFID_READ_CARD = 'Read card';
|
||
En.MIXLY_RFID_BYTE_ARRAY = 'Byte array';
|
||
En.MIXLY_STM32_OLED_DRAW_ARC = "Draw arc";
|
||
En.MIXLY_STM32_OLED_ARC = "Arc";
|
||
En.MIXLY_NominalResistance = 'Nominal Resistance';
|
||
En.MIXLY_betaCoefficient = 'Beta Coefficient';
|
||
En.MIXLY_seriesResistor = 'Series Resistor';
|
||
En.Hardware_Serial = 'Hardware Serial';
|
||
En.SOFT_RESET = 'Reset';
|
||
En.MIXLY_DIGITAL_PIN = "Digital pin";
|
||
En.MIXLY_PUSH_PULL_OUTPUT = "Push-pull output";
|
||
En.MIXLY_OPEN_DRAIN_OUTPUT = "Open drain output";
|
||
En.MIXLY_ONEWIRE_WRITE_BIT = "Write bit";
|
||
En.MIXLY_ONEWIRE_READ_BIT = "Read bit";
|
||
En.MIXLY_I2C_TRY_TO_OCCUPY_THE_BUS = "Occupy the bus";
|
||
En.MIXLY_I2C_RELEASE_BUS = "Release bus";
|
||
En.MIXLY_SPIC_WRITE_NUM = "Write number";
|
||
En.MIXLY_SPIC_READ_NUM = "Read number";
|
||
En.MIXLY_ESP32S2_LED_SETBRIGHT = "Set the current brightness of the embedded LED light (0 ~ 65535)";
|
||
En.MIXLY_PYTHON_NAME_MAIN = "Use as main program";
|
||
En.MIXLY_GET_TEMPRATURE = "Gets the value of the temperature sensor";
|
||
En.MIXLY_GET_IRREMOTE_VALUE = "Gets the value of the irromote";
|
||
En.MIXLY_YEARDAY = 'year day';
|
||
En.MIXLY_ISDIST = 'is dist';
|
||
En.MIXLY_HCSR04_INIT = "Initialize ultrasound";
|
||
En.HSV_H = 'Hue';
|
||
En.HSV_S = 'Saturation';
|
||
En.HSV_V = 'Value';
|
||
En.MIXLY_EMQX_INIT_CLIENT = 'initialize client';
|
||
En.MIXLY_EMQX_SERVER = 'server address';
|
||
En.MIXLY_EMQX_PORT = 'port number';
|
||
En.MIXLY_EMQX_USERNAME = 'user name';
|
||
En.MIXLY_EMQX_PASSWORD = 'password';
|
||
En.MIXLY_EMQX_CLIENT_ID = 'client ID';
|
||
En.MIXLY_EMQX_IS_SSL = 'ssl or not';
|
||
En.MIXLY_EMQX_SOCKET_POOL = 'connection pool';
|
||
En.MIXLY_EMQX_SSL_CONTEXT = 'ssl context';
|
||
En.MIXLY_EMQX_PUBLISH = 'Send data';
|
||
En.MIXLY_EMQX_PUBLISH_NEW = 'Publish message';
|
||
En.MIXLY_EMQX_PUBLISH_TOPIC = 'theme';
|
||
En.MIXLY_EMQX_PUBLISH_MSG = 'message';
|
||
En.MIXLY_EMQX_DEINIT = 'release client';
|
||
En.MIXLY_EMQX_SPECIAL = 'special';
|
||
En.MIXLY_EMQX_SET_METHOD = 'set callback function';
|
||
En.MIXLY_EMQX_REMOVE_METHOD = 'clear callback function';
|
||
En.MIXLY_EMQX_FOR = 'is';
|
||
En.MIXLY_EMQX_SET_USERNAME = 'set user name';
|
||
En.MIXLY_EMQX_SET_PASSWORD = 'set password';
|
||
En.MIXLY_EMQX_HOST = 'IP address';
|
||
En.MIXLY_EMQX_CONNECT = 'connect';
|
||
En.MIXLY_EMQX_RECONNECT = 're connect';
|
||
En.MIXLY_EMQX_CONNECT_ON = 'Start proxy connection';
|
||
En.MIXLY_EMQX_CLEAN_SESSION = 'lasting dialogue';
|
||
En.MIXLY_EMQX_PORT = 'proxy network port';
|
||
En.MIXLY_EMQX_KEEP_ALIVE = 'maximum communication time';
|
||
En.MIXLY_EMQX_DISCONNECT = 'disconnect';
|
||
En.MIXLY_EMQX_RETAIN = 'return value';
|
||
En.MIXLY_RETAIN = 'proxy save';
|
||
En.MIXLY_EMQX_QOS = 'service quality';
|
||
En.MIXLY_WIFI_CONNECT = 'connect Wi Fi';
|
||
En.MIXLY_WIFI_USERNAME = 'user name';
|
||
En.MIXLY_WIFI_PASSWORD = 'password';
|
||
En.MIXLY_IOT_PASSWORD = 'key';
|
||
En.MIXLY_SSL_DEFAULT = 'ssl default context';
|
||
En.MIXLY_CREATE_SOCKETPOOL = 'create connection pool for Wi Fi';
|
||
En.MIXLY_EMQX_SUBSCRIBE = 'subscribe';
|
||
En.MIXLY_EMQX_UNSUBSCRIBE = 'unsubscribe';
|
||
En.MIXLY_EMQX_LOOP = 'circular receive subscription timeout';
|
||
En.MIXLY_EMQX_LOOPONE = 'second';
|
||
En.MIXLY_EMQX_IS_CONNECT = 'whether the connection is successful';
|
||
En.MIXLY_EMQX_NABLE_LOGGER = 'enable logging';
|
||
En.MIXLY_EMQX_NABLE_LOGGERONE = 'level';
|
||
En.MIXLY_EMQX_DISABLE_LOGGER = 'disable logging';
|
||
En.MIXLY_EMQX_PING = 'server response';
|
||
En.QJ00X_MP3 = 'QJ00X MP3 Module';
|
||
En.set_ZH_TW_Font = 'Set traditional Chinese';
|
||
En.ADS1015_Get_Value = 'ADS1015 Module';
|
||
En.ADS1015_setGain = "ADS1015 Set Gain";
|
||
En.MIXLY_IR_RANGE = 'Double Infrared Ranging';
|
||
En.MIXLY_LASER_RANGE = 'Laser range finder';
|
||
En.MIXLY_TEM_HUM = 'Temperature and humidity sensor';
|
||
En.MIXLY_GET_ALTITUDE = 'Get Altitude';
|
||
En.MIXLY_GET_LIGHT_INTENSITY = 'Get Light Intensity';
|
||
En.MIXLY_GET_DISTANCE = 'Get Distance';
|
||
En.MIXLY_EMQX_PROJECT = 'project';
|
||
En.MIXLY_ESP32_INITIAL_DIGITAL_TUBEFOOT = 'Initialize one of the pins of the input as a digital pin and number it';
|
||
En.MIXLY_ESP32_DIGITALINOUT_MODE = 'Set input or output type for a digital pin';
|
||
En.MIXLY_ESP32_S2_SET_RAW_TIME = 'Gets and returns the formatted time of the selected time';
|
||
En.MIXLY_ESP32_SET_ONBOARD_MUSIC_STOP = 'End playing sound';
|
||
En.MIXLY_ESP32_ROLL_SHOW_STRING = 'Scroll display string on screen';
|
||
En.MPYTHON_BLYNKTIMER_TOOL = 'Determine available timers';
|
||
En.MPYTHON_BLYNK_STOP_TIMERS = 'Stop the corresponding timer';
|
||
En.MPYTHON_BLYNK_SENSOR_DATA_TO_APP_TOOLTIP = 'Send data to virtual pin';
|
||
En.MIXLY_ESP32_IOT_WIFI_RADIO_CONNECT_TOOLTIP = 'Connect WiFi with username and password';
|
||
En.MIXLY_ESP32_IOT_WIFI_RESET_TOOLTIP = 'WiFi Reset';
|
||
En.MIXLY_ESP32_IOT_EMQX_INIT_TOOLTIP = 'Server address default is 39.101.161.127, proxy port default is 1883, enter user name, password, enter project, create connection pool for WiFi, SSL default context';
|
||
En.MIXLY_ESP32_IOT_EMQX_PUBLISH_TOOLTIP = 'Send a message on a subject';
|
||
En.MIXLY_ESP32_IOT_EMQX_PUBLISH_MORE_TOOLTIP = 'Send a message on a topic, set the sending location, set the agent save, set the quality of service';
|
||
En.MIXLY_ESP32_IOT_EMQX_SUBSCRIBE_TOOLTIP = 'Subscription Subject';
|
||
En.MIXLY_ESP32_IOT_EMQX_SUBSCRIBE_MORE_TOOLTIP = 'Subscribe to topics, set quality of service';
|
||
En.MIXLY_ESP32_IOT_EMQX_UNSUBSCRIBE_TOOLTIP = 'Unsubscribe Subject';
|
||
En.MIXLY_ESP32_IOT_EMQX_LOOP_TOOLTIP = 'Receive subscriptions circularly';
|
||
En.MIXLY_ESP32_IOT_EMQX_CONNECT_TOOLTIP = 'MQTT Connection';
|
||
En.MIXLY_ESP32_IOT_EMQX_DISCONNECT_TOOLTIP = 'MQTT Disconnect';
|
||
En.MIXLY_ESP32_IOT_EMQX_IS_CONNECT_TOOLTIP = 'Determine if MQTT is successfully connected';
|
||
En.MIXLY_ESP32_IOT_EMQX_RECONNECT_TOOLTIP = 'MQTT Reconnection';
|
||
En.MIXLY_ESP32_IOT_EMQX_PING_TOOLTIP = 'MQTT server-side response';
|
||
En.MIXLY_ESP32_IOT_EMQX_ENABLE_LOGGER_TOOLTIP = 'Enable logging, set level';
|
||
En.MIXLY_ESP32_IOT_EMQX_ADD_TOPIC_CALLBACK_TOOLTIP = 'Set a callback function for a topic';
|
||
En.MIXLY_ESP32_IOT_EMQX_REMOVE_TOPIC_CALLBACK_TOOLTIP = 'Clear callback functions for a topic';
|
||
En.MIXLY_ESP32_IOT_EMQX_USERNAME_PW_SET_TOOLTIP = 'Set User Name and Password';
|
||
En.MIXLY_ESP32_IOT_MAP_FORMATING = 'Format location information';
|
||
En.MIXLYCAR_WHEEL_LEFT_UP = 'Left Front Wheel';
|
||
En.MIXLYCAR_WHEEL_LEFT_DOWN = 'Left rear wheel';
|
||
En.MIXLYCAR_WHEEL_RIGHT_UP = 'right-front wheel';
|
||
En.MIXLYCAR_WHEEL_RIGHT_DOWN = 'Right rear wheel';
|
||
En.MIXGO_WAVE = 'Play waveform sound';
|
||
En.MIXGO_WAVE_IS_PLAYING = 'Is the waveform sound playing?';
|
||
En.MIXGO_LEFT_MID = 'Middle-left ';
|
||
En.MIXGO_RIGHT_MID = 'Middle-right ';
|
||
En.MIXGO_LEFT_FRONT = 'Front-left ';
|
||
En.MIXGO_RIGHT_FRONT = 'Front-right ';
|
||
En.MIXGO_LEFT_BACK = 'Back-left ';
|
||
En.MIXGO_RIGHT_BACK = 'Back-right ';
|
||
En.MIXGO_LINE_SENSOR = 'track sensor status';
|
||
En.MIXGO_PROXIMITY_SENSOR = 'proximity sensor value';
|
||
En.MIXGO_ACC_8658_SENSOR = 'Acquiring six-axis acceleration sensor';
|
||
En.MIXGO_CAR_READBUSY = 'ReadBusy?';
|
||
En.MIXGO_CE_SPEAKER = 'Speaker';
|
||
En.MIXGO_CAR_KEEP_FORWARD = 'Keeping Forward';
|
||
En.MIXGO_CAR_KEEP_BACK = 'Keeping Backward';
|
||
En.MIXGO_CAR_KEEP_LEFT = 'Keeping Turn Left';
|
||
En.MIXGO_CAR_KEEP_RIGHT = 'Keeping Turn Right';
|
||
En.MIXLY_MP3_UDISK = 'USB flash drive';
|
||
En.MIXLY_MP3_SOURCE = 'Music Source';
|
||
En.WeatherGet = 'Refresh Weather City';
|
||
En.WeatherGetToday = 'Get today data';
|
||
En.TodayQuality = 'air quality';
|
||
En.WeatherGetForecast = 'Get forecast data 15day';
|
||
En.ForecastHigh = 'High temperature';
|
||
En.ForecastLow = 'Low temperature';
|
||
En.ForecastYmd = 'ymd';
|
||
En.ForecastAqi = 'Air Quality Index';
|
||
En.ForecastFx = 'wind direction';
|
||
En.ForecastFl = 'wind power';
|
||
En.ForecastType = 'weather';
|
||
En.MIXLY_DewPoint = 'Dew Point';
|
||
En.SPACE_ALLOCATION = 'Space allocation';
|
||
En.MIXLY_LIVE_WEATHER = 'Live Weather';
|
||
En.MIXLY_3_DAY_WEATHER_FORECAST = '3 days weather forecast';
|
||
En.MIXLY_6_LIFE_INDEXES = '6 Life Index';
|
||
En.MIXLY_INFORMATION_CONFIGURATION = 'Information Configuration';
|
||
En.MIXLY_GEOGRAPHIC_LOCATION = 'Geographical Location';
|
||
En.MIXLY_API_PRIVATE_KEY = 'API Private Key';
|
||
En.MIXLY_LANGUAGE = 'Language';
|
||
En.MIXLY_CELSIUS = 'Celsius';
|
||
En.MIXLY_FAHRENHEIT = 'Fahrenheit';
|
||
En.MIXLY_TEMPERATURE_UNIT = 'Temperature Unit';
|
||
En.MIXLY_GET_DATA_UPDATE_TIME = 'Get data update time';
|
||
En.MIXLY_GET_SERVER_RESPONSE_STATUS_CODE = 'Get server response status code';
|
||
En.MIXLY_WEATHER_PHENOMENON = 'Weather Phenomena';
|
||
En.MIXLY_WEATHER_PHENOMENON_CODE = 'Weather phenomenon code';
|
||
En.MIXLY_TODAY = 'Today';
|
||
En.MIXLY_TOMORROW = 'Tomorrow';
|
||
En.MIXLY_DAY_AFTER_TOMORROW = 'The day after tomorrow';
|
||
En.MIXLY_DAYTIME_WEATHER_PHENOMENON = 'Daytime weather phenomenon';
|
||
En.MIXLY_DAYTIME_WEATHER_PHENOMENON_CODE = 'Daytime weather phenomenon code';
|
||
En.MIXLY_EVENING_WEATHER_PHENOMENON = 'Night weather phenomenon';
|
||
En.MIXLY_EVENING_WEATHER_PHENOMENON_CODE = 'Evening weather phenomenon code';
|
||
En.MIXLY_PROBABILITY_OF_PRECIPITATION = 'Precipitation Probability(%)';
|
||
En.MIXLY_WIND_SPEED = 'Wind Speed';
|
||
En.MIXLY_WIND_RATING = 'Wind rating';
|
||
En.MIXLY_CAR_WASH_INDEX = 'Car Wash Index';
|
||
En.MIXLY_DRESSING_INDEX = 'Dressing Index';
|
||
En.MIXLY_COLD_INDEX = 'Cold Index';
|
||
En.MIXLY_MOVEMENT_INDEX = 'Motion Index';
|
||
En.MIXLY_TOURISM_INDEX = 'Tourism Index';
|
||
En.MIXLY_UV_INDEX = 'Ultraviolet Index';
|
||
En.MIXLY_CREATE_MQTT_CLIENT_AND_CONNECT = 'Create an MixIO client and connect'
|
||
En.MIXLY_HOT_WHEEL = 'Hot Wheel';
|
||
En.MIXLY_SD_CARD_FILE_SYSTEM_MOUNT = 'Install file system objects on path';
|
||
En.MIXLY_SD_CARD = 'SD Card';
|
||
En.MIXLY_RAIN = 'precipitation';
|
||
En.MIXLY_RAIN_TIME = 'seconds';
|
||
|
||
En.USE_MIXLY_KEY = 'Use Mixly Key';
|
||
En.CONNECT_TO_MIXIO = 'Connect to MixIO';
|
||
En.MQTT_SEND_MESSAGE = 'MQTT send message';
|
||
En.TO_TOPIC = 'To topic';
|
||
En.WHEN_THE_SUBJECT_IS_RECEIVED = 'When the subject is received';
|
||
En.CONTROLS_OPERATOR_UNTIL = "Until";
|
||
En.CONTROLS_WHILE_SHI = '';
|
||
En.MOTOR_DC = 'Motor';
|
||
En.MOTOR_N = 'neutral';
|
||
En.MOTOR_P = 'brake';
|
||
En.MIXLYCAR_WHEEL_LEFT = 'Left Wheel';
|
||
En.MIXLYCAR_WHEEL_RIGHT = 'Right Wheel';
|
||
En.MIXLY_MIXGOCE_NRF = 'nrf';
|
||
En.MIXLY_MIXGOCE_NRF_INIT = 'nrf init';
|
||
En.MIXLY_MIXGOCE_SET_NRF = 'nrf init channel %1 %2 power %3 %4 address %5 %6 datarate %7 %8';
|
||
En.MIXLY_MIXGOCE_NRF_SEND = 'nrf send';
|
||
En.MIXLY_MIXGOCE_NRF_RECEIVE = 'nrf receive';
|
||
En.MIXLY_MIXGOCE_SET_NRF1 = 'config channel(0~125), power, address(5bytes), datarate';
|
||
En.MIXLY_MIXIO_SHARE_KEY = 'share key';
|
||
En.MIXLY_MIXGOPE_FIELD = 'magnetic field';
|
||
En.MIXLY_MIXGOPE_AMPLITUDE = 'amplitude';
|
||
En.MIXGO_LINE_SENSOR_VAL = 'track sensor value';
|
||
En.MIXLY_MIXGO_CAR_SENSOR_ONBOARD_CHANGE = 'The onboard sensor is set to';
|
||
En.MIXLY_MIXGO_CAR_USE_LINE_ONLY = 'Use track only';
|
||
En.MIXLY_MIXGO_CAR_USE_PROXIMITY_ONLY = 'Use obstacle avoidance only';
|
||
En.MIXLY_MIXGO_CAR_SENSOR_ONBOARD_AUTO_CHANGE = 'Auto changed';
|
||
En.MIXLY_MIXGO_CAR_BATTERY_LEFT = 'Remaining battery(V)'
|
||
En.MIXLY_MACHINE_WDT='WDT'
|
||
En.MIXLY_MACHINE_WDT_TIMEOUT='timeout'
|
||
En.MIXLY_MACHINE_WDT_INIT_TOOLTIP='Initialize the watchdog and set the feeding time'
|
||
En.MIXLY_MACHINE_FEED='feeding'
|
||
En.MIXLY_MACHINE_WDT_FEED_TOOLTIP='regular feeding (call) is required. Once the interval is exceeded, it will be restarted'
|
||
En.MIXLY_MACHINE_RESET='RESET'
|
||
En.MIXLY_MACHINE_RESET_TOOLTIP='resets the device in a manner similar to pushing the external RESET button'
|
||
En.MIXLY_MP_ESPNOW_INIT_TOOLTIP= 'Initialize ESPNow and set channel 0-13, power 2-21db';
|
||
En.MIXLY_MP_ESPNOW_RADIO_INIT_TOOLTIP= 'channel 0-13, power 2-21db';
|
||
En.MIXLY_MP_ESPNOW_RADIO_INIT= 'set the radio channel to';
|
||
En.MIXLY_MP_ESPNOW_RADIO= 'radio';
|
||
En.MIXLY_MP_ESPNOW_RADIO_MSG_RECEIVED= 'When a message is received by radio';
|
||
En.MIXLY_MP_ESPNOW_RADIO_MSG_RECEIVED_CERTAIN= 'When message received by radio is';
|
||
En.MIXLY_MP_ESPNOW_RADIO_RECEIVED_MSG= 'Message received by radio';
|
||
En.MIXLY_MP_ESPNOW_CHANNEL= 'channel';
|
||
En.MIXLY_MIXGO_ESPNOW_MAC= 'Get local MAC address';
|
||
En.MIXLY_MIXGO_ESPNOW_INFO= 'Get source MAC address and signal strength';
|
||
En.MIXLY_MIXGO_ESPNOW_SEND='Send message';
|
||
En.MIXLY_MIXGO_ESPNOW_SEND_MAC='To MAC address';
|
||
En.MIXLY_MIXGO_ESPNOW_SEND_TOOLTIP='The MAC address is 12 bits. If the MAC address is "FFFFFFFFFF", the broadcast message is sent. Send up to 250 bytes of content';
|
||
En.MIXLY_MIXGO_ESPNOW_RECV='Receive message';
|
||
En.MIXLY_GAME_INIT = 'Initialize map';
|
||
En.MIXLY_GAME_MOVE_FORWARD = 'move forward';
|
||
En.MIXLY_GAME_MOVE_BACKWARD = 'move backward';
|
||
En.MIXLY_GAME_TURN1 = 'turn';
|
||
En.MIXLY_GAME_Turn_LEFT = 'left';
|
||
En.MIXLY_GAME_Turn_RIGHT = 'right';
|
||
En.MIXLY_GAME_TURN2 = '';
|
||
En.MIXLY_GAME_ISDONE = 'Whether to reach the end?';
|
||
En.MIXLY_GAME_ISPATH1 = 'Is there a path on the';
|
||
En.MIXLY_GAME_ISPATH_LEFT = 'left';
|
||
En.MIXLY_GAME_ISPATH_RIGHT = 'right';
|
||
En.MIXLY_GAME_ISPATH2 = '?';
|
||
En.MIXLY_WEB_PLACE = "location";
|
||
En.MIXLY_WEB_KEY = "key";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW=" Get weather report";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_DAILY=" Get daily weather forecast";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_HOURS=" Get hourly weather forecast";
|
||
En.MIXLY_WEB_DAILY = "days";
|
||
En.MIXLY_WEB_HOURS = "hour";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_ALARM="Obtain meteorological disaster warning";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_LIFE_SUGGESTION="Get life index";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_AIR_NOW="Get real air quality";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_AIR_DAILY="Get daily air quality forecast";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_TIDE_DAILY="Get 24-hour tide forecast";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_GEO_SUN="Get sunrise and sunset information";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_GEO_MOON="Get information about the moon and its phases";
|
||
En.MIXLY_DEPRECATED = "Deprecated";
|
||
En.MIXLY_DEPRECATED_WARNING_TEXT = "Warning: This block is deprecated and will be removed in the future";
|
||
En.LANG_LISTS_GET_VALUE_BY_INDEX_TOOLTIP = 'Returns the value at the specified position in a list, index starts at 0.';
|
||
En.LANG_LISTS_SET_VALUE_BY_INDEX_TOOLTIP = 'Sets the value at the specified position in a list, index starts at 0.';
|
||
En.MICROPYTHON_DISPLAY_FONT_SPACE = "space";
|
||
En.MICROPYTHON_DISPLAY_YES = "yes";
|
||
En.MICROPYTHON_DISPLAY_NO = "no";
|
||
En.MIXLY_ESP32_MONITOR_SHOW_FRAME = 'show string by frame';
|
||
En.ME_GO_LIGHT_HEADLIGHT = 'headlight';
|
||
En.ME_GO_MOTOR_EXTERN = 'external';
|
||
En.ME_GO_HALL_SENSOR = 'Hall sensor';
|
||
En.ME_GO_HALL_SENSOR_TURN = 'turns';
|
||
En.ME_GO_HALL_SENSOR_DISTANCE = 'distance';
|
||
En.ME_GO_SENSOR_MODE_OFF = 'off';
|
||
En.MIXGO_ME_DISPLAY_VERTICAL = 'vertical';
|
||
En.MIXGO_ME_DISPLAY_HORIZONTAL = 'horizontal';
|
||
En.MIXLY_INCREMENT = 'increment';
|
||
En.MIXLY_UPPERBOUND = 'upper bound';
|
||
En.MIXLY_LOWERBOUND = 'lower bound';
|
||
En.MIXLY_ENCODER_CHANGED = 'Changed';
|
||
En.MIXLY_ENCODER_LEFT_ROTATION = 'Left rotation';
|
||
En.MIXLY_ENCODER_RIGHT_ROTATION = 'Right rotation';
|
||
En.MIXLY_ENCODER_UPPER_OVERFLOW = 'Upper overflow';
|
||
En.MIXLY_ENCODER_LOWER_OVERFLOW = 'Lower overflow';
|
||
En.MIXLY_AI_UNIT = 'Intelligent dialog';
|
||
En.MIXLY_AI_LANGUAGE_CHINESE = 'Chinese-Mandarin';
|
||
En.MIXLY_AI_LANGUAGE_ENGLISH = 'English';
|
||
En.MIXLY_AI_LANGUAGE_CANTONESE = 'Cantonese';
|
||
En.MICROPYTHON_HUSKYLENS_CHANGE_ALGORTHIM ="Switch to algorithm";
|
||
En.MICROPYTHON_HUSKYLENS_UNTIL_SUCCESS ="Until success";
|
||
En.MICROPYTHON_HUSKYLENS_ALGORITHM_OBJECT_TRACKING ="Object tracking";
|
||
En.MICROPYTHON_HUSKYLENS_ALGORITHM_OBJECT_RECOGNITION ="Object recognition";
|
||
En.MICROPYTHON_HUSKYLENS_ALGORITHM_LINE_TRACKING ="Line patrol";
|
||
En.MICROPYTHON_HUSKYLENS_ALGORITHM_TAG_RECOGNITION ="Label identification";
|
||
En.MICROPYTHON_HUSKYLENS_ALGORITHM_OBJECT_CLASSIFICATION ="Object classification";
|
||
En.MICROPYTHON_HUSKYLENS_ALGORITHM_QR_CODE_RECOGNTITION ="QR code recognition";
|
||
En.MICROPYTHON_HUSKYLENS_ALGORITHM_BARCODE_RECOGNTITION ="ShopSavvy Barcode Scanner";
|
||
En.MICROPYTHON_HUSKYLENS_COMMAND_REQUEST ="Request primary data storage results";
|
||
En.MICROPYTHON_HUSKYLENS_READ_LEART_ID_COUNT ="Total learned IDS";
|
||
En.MICROPYTHON_HUSKYLENS_GET_FROM_RESULT ="Get from results";
|
||
En.MICROPYTHON_HUSKYLENS_IS_APPEAR ="Is it in the picture";
|
||
En.MICROPYTHON_HUSKYLENS_IS_LEARNED ="Have you learned";
|
||
En.MICROPYTHON_HUSKYLENS_NEAR_CENTERED ="Near the center";
|
||
En.MICROPYTHON_HUSKYLENS_X_CENTERED ="X Center";
|
||
En.MICROPYTHON_HUSKYLENS_Y_CENTERED ="Y Center";
|
||
En.MICROPYTHON_HUSKYLENS_X_ORIGIN ="X starting point";
|
||
En.MICROPYTHON_HUSKYLENS_Y_ORIGIN="Y starting point";
|
||
En.MICROPYTHON_HUSKYLENS_X_TARGET ="X end point";
|
||
En.MICROPYTHON_HUSKYLENS_Y_TARGET ="Y end point";
|
||
En.MICROPYTHON_HUSKYLENS_ORDER ="NO.";
|
||
En.MICROPYTHON_HUSKYLENS_ORDER_END =" ";
|
||
En.MICROPYTHON_HUSKYLENS_SUM ="total";
|
||
En.MICROPYTHON_HUSKYLENS_LEARN_ONCE ="Automatic learning once";
|
||
En.MICROPYTHON_HUSKYLENS_FORGET ="Forget all learning data of the current algorithm";
|
||
En.MICROPYTHON_HUSKYLENS_SET_CURRENT ="Set current algorithm";
|
||
En.MICROPYTHON_HUSKYLENS_NAME ="Name is";
|
||
En.MICROPYTHON_HUSKYLENS_SCREEN_TEXT ="Screen overlay display text";
|
||
En.MICROPYTHON_HUSKYLENS_SCREEN_CLEAR ="Clear the text displayed on the screen";
|
||
En.MICROPYTHON_HUSKYLENS_TRIGGER ="trigger";
|
||
En.MICROPYTHON_HUSKYLENS_SAVE_SDCARD ="Save to SD card";
|
||
En.MICROPYTHON_HUSKYLENS_PHOTO ="photograph";
|
||
En.MICROPYTHON_HUSKYLENS_SCREENSHOT ="Screenshot";
|
||
En.MICROPYTHON_HUSKYLENS_SAVE_AS ="preservation";
|
||
En.MICROPYTHON_HUSKYLENS_LOAD ="load";
|
||
En.MICROPYTHON_HUSKYLENS_SDCARD_MODEL ="Current algorithm data is SD card";
|
||
En.MICROPYTHON_HUSKYLENS_MODEL_NUM ="Model No";
|
||
En.MIXLY_ESP32_MAX30102 = "heart rate and blood oxygen sensor";
|
||
En.MIXLY_ESP32_MAX30102_IR = "heart rate";
|
||
En.MIXLY_ESP32_MAX30102_RED = "blood oxygen";
|
||
En.MIXLY_ESP32_APDS9960 = "gesture sensor";
|
||
En.MIXLY_ESP32_APDS9960_COLOR = "color recognition";
|
||
En.MIXLY_ESP32_APDS9960_GESTURE = "gesture recognition";
|
||
En.MIXLY_ESP32_APDS9960_APPROACH = "proximity recognition";
|
||
En.MIXLY_BLE_HANDLE = "bluetooth handle";
|
||
En.MIXLY_ACC_SHAKE = "shake";
|
||
|
||
En.MPYTHON_DISPLAY_MODE_0 = 'erase';
|
||
En.MPYTHON_DISPLAY_MODE_1 = 'draw';
|
||
En.MPYTHON_DISPLAY_HOLLOW = 'hollow';
|
||
En.MPYTHON_DISPLAY_SOLID = 'solid';
|
||
En.MPYTHON_DISPLAY_SHAPE_RECT_MESSAGE0 = '%1 %2 rectangle %3 x %4 y %5 width %6 height %7';
|
||
En.MPYTHON_DISPLAY_SHAPE_RECT_TOOLTIP = '';
|
||
En.mpython_horizontal = 'horizontal';
|
||
En.mpython_vertical = 'vertical';
|
||
En.MPYTHON_DISPLAY_HVLINE_MESSAGE0 = '%1 %2 line %3 x %4 y %5 length %6';
|
||
En.MPYTHON_DISPLAY_HVLINE_TOOLTIP = '';
|
||
En.mpython_display_hline_0 = 'erase';
|
||
En.mpython_display_hline_1 = 'draw';
|
||
En.mpython_display_line_MESSAGE0 = '%1 line %2 x1 %3 y1 %4 to x2 %5 y2 %6';
|
||
En.mpython_display_line_TOOLTIP = '';
|
||
En.MIXLY_MIDI = 'buzzer';
|
||
En.MIXLY_CODE_RATE = 'coding rate';
|
||
En.MIXLY_SPREADING_FACTOR = 'spreading factor';
|
||
En.MIXLY_TX_POWER = 'tx power';
|
||
En.MIXLY_SIGNAL_BANDWIDTH = 'signal bandwidth';
|
||
En.MIXLY_PACKAGE = 'package';
|
||
En.MIXLY_SIGNAL_STRENGTH = 'signal intensity';
|
||
En.MIXLY_SIGNAL_NOISE_RATE = 'signal to noise ratio';
|
||
En.MIXLY_LORA_INIT_TOOLTIP = 'frequency:433±20, coding rate:5~8, spreading factor:6~12, tx power:5~23';
|
||
En.ROTATION_FORWARD = "forward rotation";
|
||
En.ROTATION_BACKWARD = "backward rotation";
|
||
En.ME_GO_PITCH = 'pitch';
|
||
En.ME_GO_ROLL = 'roll';
|
||
En.BOARD_DIRECTION = 'board condition';
|
||
En.MIXLY_GET_GESTURE = 'get car gesture';
|
||
En.MIXLY_GET_GESTURE_ALL = 'get gesture';
|
||
En.MIXLY_SET_VOLUME = 'set volume';
|
||
En.MIXLY_SET_VOLUME_TOOLTIP = 'volume range 0-16';
|
||
En.MIXLY_GET_VOLUME = 'get volume';
|
||
En.MIXLY_PLAY_HINTS = 'play built-in prompt sound';
|
||
En.MIXLY_PLAY_HINTS_TOOLTIP = 'built-in prompt sound range 0-47';
|
||
En.MIXLY_BACKGROUND_MUSIC = 'background music';
|
||
En.MIXLY_PROGRAM_BLOCK = 'wait until over';
|
||
En.MIXLY_PLAY_TTS_TOOLTIP = 'background music range 0-15, 0 for no background music';
|
||
En.MIXLY_GET_NTP = 'get network time';
|
||
En.MIXLY_ME_GO_CAR_SENSOR_ONBOARD_AUTO_CHANGE = 'Auto changed';
|
||
En.MIXLY_ME_GO_CAR_LIGHT_SEEKING_ONLY = 'Use light chasing only';
|
||
En.MIXLY_ME_GO_CAR_LIGHT_SEEKING_SENSOR = 'light chasing sensor';
|
||
En.MIXLY_OTHER = 'other';
|
||
En.MIXLY_CONCENTRATION = 'concentration';
|
||
En.MIXLY_PM_CONCENTRATION_TOOLTIP = 'Concentration unit ug/m³';
|
||
En.MIXLY_QR_CODE_RECOGNTITION = "QR code Tag code";
|
||
En.MIXLY_QR_CODE_ANALYSIS = "ergodic analysis";
|
||
En.MIXLY_QR_CODE = "QR code";
|
||
En.MIXLY_POSITION_XY = "coordinate";
|
||
En.MIXLY_AI_SENSOR_QR_CODE_TOOLTIP = "Obtain the corresponding information of the QR code object";
|
||
En.MIXLY_AI_SENSOR_QR_CODE_RECOGNTITION_TOOLTIP = "Use the MixGo AI camera to identify the QR code, and return a list containing all the identification result objects";
|
||
En.MIXLY_AI_SENSOR_CONFIG_TOOLTIP = "Set the port where MixGo AI interacts with the board";
|
||
En.MIXLY_BAR_CODE = "bar code";
|
||
En.MIXLY_BAR_CODE_RECOGNTITION = "Barcode recognition";
|
||
En.MIXLY_AI_SENSOR_BAR_CODE_TOOLTIP = "Get the corresponding information of the barcode object";
|
||
En.MIXLY_AI_SENSOR_BAR_CODE_RECOGNTITION_TOOLTIP = "Use the MixGo AI camera to identify barcode and return a list containing all the identified result objects";
|
||
En.MIXLY_TAG = "Tag code";
|
||
En.MIXLY_TAG_RECOGNTITION = "Tag code recognition";
|
||
En.MIXLY_AI_SENSOR_TAG_TOOLTIP = "Obtain the corresponding information of the label code object";
|
||
En.MIXLY_AI_SENSOR_TAG_RECOGNTITION_TOOLTIP = "Use MixGo AI camera identification tag code to return a list containing all identification result objects";
|
||
En.MIXLY_LINE = "straight line";
|
||
En.MIXLY_LINE_RECOGNTITION = "Line recognition";
|
||
En.MIXLY_AI_SENSOR_LINE_TOOLTIP = "Get the corresponding information of line objects";
|
||
En.MIXLY_AI_SENSOR_LINE_RECOGNTITION_TOOLTIP = "Use the MixGo AI camera to recognize straight lines and return a list containing all the objects identified";
|
||
En.MIXLY_LINE_RECOGNTITION_ANGLE = "Merge Angle";
|
||
En.MIXLY_LINE_RECOGNTITION_SLOPE = "Merge slope";
|
||
En.MIXLY_LINE_ANGLE = "Line angle";
|
||
En.MIXLY_CIRCLE = "circular";
|
||
En.MIXLY_CIRCLE_RECOGNTITION = "Circle recognition";
|
||
En.MIXLY_AI_SENSOR_CIRCLE_TOOLTIP = "Get the corresponding information of the circular object";
|
||
En.MIXLY_AI_SENSOR_CIRCLE_RECOGNTITION_TOOLTIP = "Use the MixGo AI camera to identify circles and return a list containing all the objects identified";
|
||
En.MIXLY_CIRCLE_RECOGNTITION_MAX = "Merge Minimum Radius";
|
||
En.MIXLY_CIRCLE_RECOGNTITION_MIN = "Merge maximum radius";
|
||
En.MIXLY_CIRCLE_AREA = "the measure of area";
|
||
En.MIXLY_RECT = "rectangle";
|
||
En.MIXLY_RECT_RECOGNTITION = "Rectangle recognition";
|
||
En.MIXLY_AI_SENSOR_RECT_TOOLTIP = "Get the corresponding information of the rectangular object";
|
||
En.MIXLY_AI_SENSOR_RECT_RECOGNTITION_TOOLTIP = "Use MixGo AI camera to recognize rectangle, and return a list containing all recognition result objects";
|
||
En.MIXLY_COLOR_RECOGNTITION = "Color recognition";
|
||
En.MIXLY_COLOR_ANALYSIS = "Color analysis";
|
||
En.MIXLY_AI_SENSOR_COLOR_TOOLTIP = "Get the corresponding information of the color object";
|
||
En.MIXLY_AI_SENSOR_COLOR_RECOGNTITION_TOOLTIP = "Use the MixGo AI camera to identify colors, and return a list containing all the objects identified";
|
||
En.MIXLY_COLOR_LAB = "Gamut";
|
||
En.MIXLY_AI_SENSOR_COLOR_THRESHOLD = "LAB threshold zoom range";
|
||
En.MIXLY_COLOR_CHASE = "Color Tracking";
|
||
En.MIXLY_COLOR_CHASE_MERGE = "merge";
|
||
En.MIXLY_COLOR_CHASE_ANALYSIS = "analysis";
|
||
En.MIXLY_ANALYSIS_RESULT = 'analysis result';
|
||
En.MIXLY_AI_SENSOR_RGB_TOOLTIP = "Set the color values (0~255) of the two RGB lights of the MixGo AI camera respectively, and the parameters are sequences containing three items";
|
||
En.MIXLY_LOCAL_TRAIN = "Self model training";
|
||
En.MIXLY_OBJECT_LIST = "Item List";
|
||
En.MIXLY_MODEL_NAME = "Model name";
|
||
En.MIXLY_TRAIN_TIME = "Training times";
|
||
En.MIXLY_AI_SENSOR_LOCAL_TRAIN_TOOLTIP = "Use the camera to acquire images for model training, and stop communication during model training";
|
||
En.MIXLY_LOCAL_CLASS = "Self model recognition";
|
||
En.MIXLY_CONFIDENCE_DEGREE = "Confidence";
|
||
En.MIXLY_AI_SENSOR_LOCAL_CLASS_TOOLTIP = "Obtain the corresponding information from the model recognition result object";
|
||
En.MIXLY_MUSIC_RECORD = "audio recording";
|
||
En.MIXLY_MUSIC_PLAY = "Audio play";
|
||
En.MIXLY_AI_SENSOR_MUSIC_RECORD_TOOLTIP = "Use MixGo AI camera to record audio without blocking the recording process";
|
||
En.MIXLY_YOLO_RECOGNIZE = "External model loading";
|
||
En.MIXLY_ANCHOR = "Anchor parameters";
|
||
En.MIXLY_MODEL_PATH = "Model Path";
|
||
En.MIXLY_AI_SENSOR_YOLO_RECOGNIZE_TOOLTIP = "Use the camera to read the model file in the SD card for item identification, and return a list containing all the identification result objects";
|
||
En.MIXLY_AI_SENSOR_YOLO_RECOGNIZE_RESULT_TOOLTIP = "Get the corresponding information of the external model loading result object";
|
||
En.MPYTHON_DISPLAY_SHAPE_RECT_MESSAGE1 = 'OLED Screen %1 %2 %3 rectangle %4 x %5 y %6 width %7 height %8';
|
||
En.MPYTHON_DISPLAY_HVLINE_MESSAGE1 = 'OLED Screen %1 %2 %3 line %4 x %5 y %6 length %7';
|
||
En.mpython_display_line_MESSAGE1 = 'OLED Screen %1 %2 line %3 x1 %4 y1 %5 to x2 %6 y2 %7';
|
||
En.MIXLY_REQUESTS_GET = 'request(GET)';
|
||
En.MIXLY_GET_CURRENT_TIME = 'get current time';
|
||
En.MIXLY_REQUESTS_ALL = 'all message';
|
||
En.MIXLY_REQUESTS_MESSAGE = 'message content';
|
||
En.MIXLY_REQUESTS_LEN = 'send-packet length';
|
||
En.MIXLY_REQUESTS_GET_LEN = 'received-packet length';
|
||
En.MIXLY_CONNECTTO = 'connect to';
|
||
En.MIXLY_INIT_SUBSCRIBE = 'initialize and subscribe';
|
||
En.MIXLY_OPEN_DEBUG = 'debug';
|
||
En.MIXLY_USE_STRING = 'use string/tuple';
|
||
En.MIXLY_PM25_SENSOR = 'PM2.5 dust sensor';
|
||
En.MIXLY_GNSS_SENSOR = 'GNSS locator';
|
||
En.MIXLY_GNSS_SENSOR_GET_TIME_TOOLTIP = 'return a list of satellite data time information，#0year,1month,2day,3week,4hour,5minute,6second,7microsecond';
|
||
En.MIXLY_GNSS_SENSOR_GET_LOCATE_TOOLTIP = 'return a list of location information，#0longitude direction,1longitude,2latitude direction,3latitude,4height(m),5speed(m/s),6direction°';
|
||
En.MIXLY_GNSS_SENSOR_GET_STATUS_TOOLTIP = 'return a list of status information，#0positioning is successful or not,1positioning mode,2number of satellites for positioning';
|
||
En.MIXLY_ESP32_WIFI_CONNECTION_EVENT1 = 'WIFI is connected';
|
||
En.MIXLY_ESP32_WIFI_CONNECTION_EVENT2 = 'The router successfully assigns an IP';
|
||
En.MIXLY_ESP32_WIFI_CONNECTION_EVENT3 = 'WIFI is disconnected';
|
||
En.MIXLY_MIXBOT_SHOW_SCROLL_STRING_TOOLTIP = 'Single character static display, multi character scrolling display, non blocking when scrolling display';
|
||
En.MIXLY_MIXBOT_AMBIENTBRIGHT = 'get ambient brightness';
|
||
En.MIXLY_MIXBOT_SCREEN_ROTATE = 'set screen rotation';
|
||
En.MIXLY_MIXBOT_MOTOR_STATUS = 'get motor status';
|
||
En.MIXLY_MIXBOT_MOTOR_STATUS_TOOLTIP = 'Returns two tuples, corresponding to the left and right motor states, in order of mode, speed, power, and turns'
|
||
En.MIXLY_MIXBOT_MOTOR_TURNS = 'turns';
|
||
En.MIXLY_MIXBOT_MOVE_TOOLTIP = 'Power/speed parameter range -100~100, turns parameter range -32768~32767), negative sign represents reversal';
|
||
En.MIXLY_MIXBOT_SOUND_LOUDNESS = 'get microphone volume';
|
||
En.MIXLY_MIXBOT_LINE_SENSOR_CALIBRATE_WHITE = 'calibrate white';
|
||
En.MIXLY_MIXBOT_LINE_SENSOR_CALIBRATE_BLACK = 'calibrate black';
|
||
En.MIXLY_MIXBOT_LINE_SENSOR_CALIBRATE_RESET = 'factory reset';
|
||
En.MIXLY_MIXBOT_BUZZER = 'buzzer';
|
||
En.MIXLY_AI_SENSOR_ASR_RECOGNISE_CORPUS = 'corpus';
|
||
En.MIXLY_AI_SENSOR_ASR_RECOGNISE_TOOLTIP = 'Return a tuple, contains the content and confidence level of the speech recognition result';
|
||
En.MIXLY_IR_STRENGTH = 'Infrared light intensity';
|
||
En.MIXLY_LIGHT_STRENGTH = 'Natural light intensity';
|
||
En.MIXLY_MIXBOT_MOTOR_EXTERN_TOOLTIP = 'Speed percentage range -100~100%, negative sign represents reversal';
|
||
En.MIXLY_TRAFFIC_LIGHT= 'traffic lights';
|
||
En.MIXLY_TRAFFIC_LIGHT_RED_ON= 'Red light on';
|
||
En.MIXLY_TRAFFIC_LIGHT_RED_BLINK= 'Red light flashing';
|
||
En.MIXLY_TRAFFIC_LIGHT_YELLOW_ON= 'Yellow light on';
|
||
En.MIXLY_TRAFFIC_LIGHT_YELLOW_BLINK= 'Yellow light flashing';
|
||
En.MIXLY_TRAFFIC_LIGHT_GREEN_ON= 'Green light on';
|
||
En.MIXLY_TRAFFIC_LIGHT_GREEN_BLINK= 'Green light flashing';
|
||
En.MIXLY_KNOB_POTENTIOMETER= 'Knob potentiometer';
|
||
En.MIXLY_REFLECTION_BRIGHTNESS= 'Reflection brightness';
|
||
En.MIXLY_ENVIRONMENT_BRIGHTNESS= 'Ambient brightness';
|
||
En.MIXLY_SERVO_MOTOR= 'servo motor';
|
||
En.MIXLY_RELATIVE = "relative";
|
||
En.MIXLY_MIXBOT_SERVO_BLOCK_OR_NOT = "whether blocked";
|
||
En.MIXLY_MIXBOT_SERVO_FINISH_OR_NOT = "whether finished rotating";
|
||
En.MIXLY_MIXBOT_SERVO_SET_STOP_MODE = "Set stop mode";
|
||
En.MIXLY_MIXBOT_SERVO_STOP_MODE_KEEP = "Holding Position";
|
||
En.MIXLY_MIXBOT_SERVO_STOP_MODE_COAST = "Coast";
|
||
En.MIXLY_MIXBOT_SERVO_STOP_MODE_BRAKE = "Resistance braking";
|
||
En.MIXLY_MIXBOT_SERVO_TURN_DIRECTION = "Steering settings";
|
||
En.MIXLY_MIXBOT_SERVO_NEAREST_PATH = "shortest path";
|
||
En.MIXLY_MIXBOT_SERVO_RELATIVE_ORIGIN_PATH = "Set current position as the origin";
|
||
En.MIXLY_MIXBOT_SERVO_LIKE_ENCODING_MOTOR = "like encoding motor";
|
||
En.MIXLY_MIXBOT_SERVO_LIKE_ORDINARY_MOTOR = "like ordinary motor";
|
||
En.MIXLY_MIXBOT_EXTERN_TOUCHED = "is touched";
|
||
En.MIXLY_MIXBOT_SERVO_ABSOLUTE_ANGLE_TOOLTIP = "Absolute mode angle range 0~359";
|
||
En.MIXLY_MIXBOT_SERVO_RELATIVE_ANGLE_TOOLTIP = "Relative mode angle range -8388607~8388607";
|
||
En.MIXLY_MIXBOT_EXTERN_GET_ADDR = "get address";
|
||
En.MIXLY_MIXBOT_EXTERN_SET_ADDR = "set address";
|
||
En.MIXPY_REQUESTS_GET_RESULT = 'and get result';
|
||
En.MIXLY_TOOLTIP_MOTOR_SETUP = 'Dual PWM motor drive (HR8833) initialization';
|
||
En.SHUTDOWN = 'shut down';
|
||
En.DIGITAL = 'digital';
|
||
En.ANALOG = 'analog';
|
||
En.BITBOT = 'Feiyi';
|
||
En.MIXBOT = 'MixBot';
|
||
En.MICROPYTHON_BITBOT_SHUTDOWN_TOOLTIP = 'Shut down and disconnected under battery power. Only the motor output is turned off under USB power supply.';
|
||
En.ONBOARD_TFT_DISPLAY_SHAPE_RECT_MESSAGE0 = 'draw %1 rectangle %2 x %3 y %4 width %5 height %6 color %7';
|
||
En.ONBOARD_TFT_DISPLAY_HVLINE_MESSAGE0 = 'draw %1 line %2 x %3 y %4 length %5 color %6';
|
||
En.mpython_display_line_MESSAGE0 ='draw line %1 x1 %2 y1 %3 to x2 %4 y2 %5 color %6';
|
||
En.MIXLY_TOUCH_SLIDE = "slide touch";
|
||
En.MIXLY_TOUCH_SLIDE_TOOLTIP = "The touch value is close to 0 by default, increases when touching in the direction of IO3, and decreases when touching in the direction of IO4.";
|
||
En.MIXLY_EXTERN_SONAR = "ultrasonic sensor";
|
||
En.MIXLY_EXTERN_INDICATOR_LIGHT = "pilot light";
|
||
En.MIXLY_SCREEN_FILL = "screen fill";
|
||
En.MIXLY_SDCARD_MOUNT = "mount to directory";
|
||
En.MIXLY_STRENGTH = "strength";
|
||
En.MIXLY_INIT_CLOCK = "Initialize clock";
|
||
En.MIXLY_CENTER_POS = "Center coordinate";
|
||
En.GET_RTCTIME = "Read RTC Time";
|
||
En.SET_TIME = "Set Time";
|
||
En.DRAW_CLOCK = "Draw Clock";
|
||
En.CLEAR_CLOCK = "Clear pointer";
|
||
En.ONBOARD_TFT_DISPLAY_SHAPE_CIRCLE_MESSAGE0 = 'draw %1 circle %2 x %3 y %4 radius %5 color %6';
|
||
En.RETURN_SUCCESS_OR_NOT = "return success or not";
|
||
En.MIXLY_MIXBOT_SOUND_SET_LOUDNESS = 'Set microphone volume';
|
||
En.MIXLY_RECORD_AUDIO = 'Recorde audio';
|
||
En.MIXLY_PLAY_AUDIO = 'Play audio';
|
||
En.MIXLY_PLAY_ONLINE_AUDIO = 'Play online audio';
|
||
En.MIXLY_DISPLAY_MATRIX_WRITE_NOW = 'show';
|
||
En.MIXLY_DISPLAY_MATRIX_DONT_WRITE = 'hide';
|
||
En.MIXLY_DISPLAY_MATRIX_WRITE = 'show';
|
||
En.weather_solo = 'Split-type Weather Station';
|
||
En.MIXLY_ABBR = 'abbreviation';
|
||
En.MIXLY_ACCUMULATED = 'accumulate';
|
||
En.MIXLY_AVERAGE = 'average';
|
||
En.MIXLY_AI_SENSOR_LICENSEPLATE_RECOGNTITION_TOOLTIP = 'Use MixGo AI sensor to recognize license plates and return a list containing all recognition result objects';
|
||
En.MIXLY_AI_SENSOR_LICENSEPLATE_TOOLTIP = 'Obtain the corresponding information of the license plate object';
|
||
En.MIXLY_LICENSEPLATE = 'License Plate';
|
||
En.MIXLY_FACE = 'Face';
|
||
En.MIXLY_FACE_CLASSIFIER = 'Face detection';
|
||
En.MIXLY_AI_SENSOR_FACE_TOOLTIP = 'Obtain corresponding information of face objects';
|
||
En.MIXLY_AI_SENSOR_BAR_FACE_CLASSIFIER_TOOLTIP = 'Use MixGo AI sensor to detect faces and return a list of objects containing all recognition results';
|
||
En.MIXLY_20OBJECTS = '20 objects';
|
||
En.MIXLY_FIND_20OBJECTS = '20 object recognition';
|
||
En.MIXLY_AI_SENSOR_20OBJECTS_TOOLTIP = 'Obtain the corresponding information of 20 objects';
|
||
En.MIXLY_AI_SENSOR_BAR_FIND_20OBJECTS_TOOLTIP = 'Use MixGo AI sensor to detect 20 objects and return a list containing all recognition result objects';
|
||
En.MIXLY_BUTTON = 'button';
|
||
En.WHETHER_IS_PRESSED = 'whether be held down';
|
||
En.MIXLY_GET_BATTERY = 'get battery power（v）';
|
||
En.MIXLY_GET_JOYSTICK = 'get the value of Joystick';
|
||
En.MIXLY_HANDLE_SHUTDOWN ='set handle off';
|
||
En.MIXLY_ESP32_EXTERN_GRAY_NEAR = "Infrared grayscale sensor";
|
||
En.PIN_NUMBERING = 'Port';
|
||
En.MIXLY_LIGHT_OFF = 'Light off';
|
||
En.MIXLY_LIGHT_RED = 'Red';
|
||
En.MIXLY_LIGHT_GREEN = 'Green';
|
||
En.MIXLY_LIGHT_BLUE = 'Blue';
|
||
En.MIXLY_LIGHT_YELLOW = 'Yellow';
|
||
En.MIXLY_LIGHT_CYAN = 'Cyan';
|
||
En.MIXLY_LIGHT_PURPLE = 'Purple';
|
||
En.MIXLY_LIGHT_WHITE = 'White';
|
||
En.MIXLY_EXTERN_LIGHTUV = 'Ambient light sensor';
|
||
En.MIXLY_GET_ENV_LIGHT = 'get ambient light';
|
||
En.MIXLY_ESP32_EXTERN_LIGHT = 'light intensity sensor';
|
||
En.MIXLY_GET_ULTRAVIOLET = 'get Ultraviolet intensity';
|
||
En.LOGIC_OPERATION_NOR = 'NAND';
|
||
En.LOGIC_OPERATION_XOR = 'NOR';
|
||
En.LOGIC_OPERATION_TOOLTIP_NOR = "Return true if the input results are the same, false if the two input results are different";
|
||
En.LOGIC_OPERATION_TOOLTIP_XOR = "Return true if the input results are different, false if the two input results are the same";
|
||
En.MIXLY_MIXGO_NOVA_POTENTIAL_NUM = "Get the potentiometer number";
|
||
En.MIXLY_POWER_SUPPLY = "power supply";
|
||
En.SET_USB = "set the USB2.0 interface";
|
||
En.MIXLY_SPK_STATE = "set the horn function";
|
||
En.MIXLY_IR_INPUT1 = "NEC_8";
|
||
En.MIXLY_IR_INPUT2 = "NEC_16";
|
||
En.MIXLY_IR_INPUT3 = "NEC_other";
|
||
En.MIXlY_RECV_FUN = "IRreceive";
|
||
En.MILY_PAUSE = "Pause";
|
||
En.MIXLY_RECOVER = "Recover";
|
||
En.MIXLY_IR_SEND_samsung1 = "NEC";
|
||
En.MIXLY_IR_SEND_samsung2 = "Samsung";
|
||
En.MIXLY_TR_SEND_RC = "RC5";
|
||
En.MIXLY_INTERNAL_VARIABLE = "variable";
|
||
En.MIXLY_IR_SEND = "IRsend";
|
||
En.MIXLY_CONTROL = "control bit";
|
||
En.MIXLY_TRANSMIT_CONVEN_DATA = "While using NEC/Samsung，the range of command code is 0~255、the range of address code is 0~65535、the control bit includes -1，0，1；while using RC5，the range of command code is 0~63、the range of address code is 0~31、the control bit includes 0，1";
|
||
En.MIXLY_IR_TRANSMIT_DONE = "whether the ir_transmission is Complete";
|
||
En.MIXLY_IR_CMD_CODE = "command code";
|
||
En.MIXLY_IR_ADDR_CODE = "address code";
|
||
En.MIXLY_IR_RAW_CODE = "raw code";
|
||
En.MIXLY_IR_PULSE = "pulses code";
|
||
En.MIXLY_IR_WHETHER_RECV = "wheteher receive new data";
|
||
En.MIXLY_IR_TIMEOUT = "timeout";
|
||
En.MIXLY_RTCGETTIMESTAMP = "Get Timestamp";
|
||
En.MIXLY_ESP32_RTC_GET_TIMESTAMP_TOOLTIP = "Timestamp to return real-time clock";
|
||
En.MIXLY_RTC_TIMESTAMP = "Timestamp";
|
||
En.MIXLY_TO_JSON = "convert dicts to json";
|
||
En.MIXLY_TO_JSON_TOOLTIP = "Convert dicts to json string";
|
||
En.MIXLY_CONVERT_TO_JSON = "convert json to dicts ";
|
||
En.MIXLY_CONVERT_TO_JSON_TOOLTIP = "convert json string to dicts";
|
||
En.MIXLY_DUTY_RATIO = "value,frequency";
|
||
En.MIXLY_OP_GARBAGE_COLLECT = "operate garbage collection";
|
||
En.MIXLY_GET_MEM_ALLOC = "get the allocated memory(Byte)";
|
||
En.MIXLY_GET_MEM_FREE = "get the free memory (Byte)";
|
||
En.MIXLY_GET_UNIQUE_IDEN = "Obtain the unique identifier of the main control board";
|
||
En.MIXLY_KEYBOARD_INPUT = "keyboard input";
|
||
En.MIXLY_SPECIAL_KEY = "special key";
|
||
En.MIXLY_GENERAL_KEY = "general key";
|
||
En.MIXLY_RELEASE = "automatic release";
|
||
En.MIXLY_SPECIAL_KEY0 = "no operation";
|
||
En.MIXLY_SPECIAL_KEY1 = "Left Alt key";
|
||
En.MIXLY_SPECIAL_KEY2 = "Left Shift key";
|
||
En.MIXLY_SPECIAL_KEY4 = "Left Control key";
|
||
En.MIXLY_SPECIAL_KEY8 = "Left Windows key";
|
||
En.MIXLY_SPECIAL_KEY16 = "Right Control key";
|
||
En.MIXLY_SPECIAL_KEY32 = "Right Shift key";
|
||
En.MIXLY_SPECIAL_KEY64 = "Right Alt key";
|
||
En.MIXLY_SPECIAL_KEY128 = "Right Windows key";
|
||
En.MIXLY_MOUSE_INPUT = "mouse input";
|
||
En.MIXLY_MOUSE_KEYS = "mouse button";
|
||
En.MIXLY_X_CHANGES = "change in the x axe ";
|
||
En.MIXLY_Y_CHANGES = "change in the y axe ";
|
||
En.MIXLY_MOUSE_LEFT_KEY = "left key";
|
||
En.MIXLY_MOUSE_RIGHT_KEY = "right key";
|
||
En.MIXLY_MOUSE_MID_KEY = "middle key";
|
||
En.MIXLY_WHEEL_CHANGES = "roller change amount";
|
||
En.MIXLY_STR_PRINT = "character input";
|
||
En.MIXLY_STR_PRINT_TIME_DELAY = "per character interval";
|
||
En.GENERALKEY_CONTAINER_TOOLTIP = "Add, remove, or rearrange sections to reconfigure the key combination.";
|
||
En.GENERALKEY_CREATE_EMPTY_TITLE = "Empty key combinations";
|
||
En.GENERALKEY_CREATE_WITH_INPUT_WITH = "combinate the normal keys";
|
||
En.GENERALKEY_TUPLE_CREATE_TOOLTIP = "combinate the keys as a tuple, and up to 3 keys can be combined";
|
||
En.DRAW_POINTER = "drawn pointer";
|
||
En.DRAW_POINTER_ANGLE = "angle(0~359)";
|
||
En.DRAW_POINTER_TOOLTIP = "The range of drawing pointer angles is 0~359°";
|
||
En.blockpy_REQUESTS_GET_ATTR_JSON = 'Response content JSON deserialization';
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_TEXT = "text of weather phenomena";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_CODE = "code of weather phenomena";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_FEEL = "somatosensory temperature(℃)";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_HUMIDITY = "relative humidity (%)";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_VISIBILITY = "visibility(km)";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_WIND_DIRECT_DEGREE = "wind direction degree (°)";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_WIND_SPEED = "wind speed (km/h)";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_WIND_SCALE = "wind scale";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_NOW_CLOUDS = "clouds (%)";
|
||
En.MIXLY_WEB_DATA_SENIVERSE_GET_WEATHER_DAILY_DAY = "day";
|
||
En.MIXLY_RAINFALL = "rainfall(mm)";
|
||
En.MIXLY_AIR_NOW_AIRQUAILTY = "air quality index";
|
||
En.MIXLY_AIR_NOW_PM25 = "One-hour average value of PM2.5 particles. (μg/m³)";
|
||
En.MIXLY_AIR_NOW_PM10 = "One-hour mean value of PM10 particles. (μg/m³)"
|
||
En.MIXLY_AIR_NOW_so2 = "One-hour average of sulfur dioxide. (μg/m³);"
|
||
En.MIXLY_AIR_NOW_no2 = "One-hour mean value of nitrogen dioxide. (μg/m³)";
|
||
En.MIXLY_AIR_NOW_co = "One-hour average of carbon monoxide. (μg/m³)";
|
||
En.MIXLY_AIR_NOW_o3 = "One-hour ozone average. (μg/m³)";
|
||
En.MIXLY_AIR_NOW_pp = "Primary pollutant";
|
||
En.MIXLY_AIR_NOW_quailty = "Air quality category";
|
||
En.MIXLY_AIR_NOW_last_update = "Data release time";
|
||
En.MIXLY_WEATHER_ALARM_TITLE = "title of meteorological disaster warning";
|
||
En.MIXLY_WEATHER_ALARM_TYPE = "type of meteorological disaster warning";
|
||
En.MIXLY_WEATHER_ALARM_LEVEL = "level of meteorological disaster warning";
|
||
En.MIXLY_WEATHER_ALARM_DESCRIPTION = "description of meteorological disaster warning";
|
||
En.MIXLY_WEATHER_ALARM_PUB_DATE = "publish date of meteorological disaster warning";
|
||
En.MIXLY_LIFE_SUGGESTION_AC = "air condition suggestion";
|
||
En.MIXLY_LIFE_SUGGESTION_AP = "air pollution diffusion conditions";
|
||
En.MIXLY_LIFE_SUGGESTION_AIRING = "airing";
|
||
En.MIXLY_LIFE_SUGGESTION_ALLERGY = "allergy";
|
||
En.MIXLY_LIFE_SUGGESTION_BEER = "beer";
|
||
En.MIXLY_LIFE_SUGGESTION_BOATING = "boating";
|
||
En.MIXLY_LIFE_SUGGESTION_CAR_WS = "car washing";
|
||
En.MIXLY_LIFE_SUGGESTION_CHILL = "chill";
|
||
En.MIXLY_LIFE_SUGGESTION_COMFORT = "comfort";
|
||
En.MIXLY_LIFE_SUGGESTION_DATING = "dating";
|
||
En.MIXLY_LIFE_SUGGESTION_DRESSING = "dressing";
|
||
En.MIXLY_LIFE_SUGGESTION_FISHING = "fishing";
|
||
En.MIXLY_LIFE_SUGGESTION_FLU = "flu";
|
||
En.MIXLY_LIFE_SUGGESTION_HAIR_DRESS = "hair dressing";
|
||
En.MIXLY_LIFE_SUGGESTION_KITEFLYING = "kiteflying";
|
||
En.MIXLY_LIFE_SUGGESTION_MAKEUP = "makeup";
|
||
En.MIXLY_LIFE_SUGGESTION_MOOD = "mood";
|
||
En.MIXLY_LIFE_SUGGESTION_MORNINIG_SPORT = "moring sport";
|
||
En.MIXLY_LIFE_SUGGESTION_NIGHT_LIFE = "night life";
|
||
En.MIXLY_LIFE_SUGGESTION_ROAD_CONDI = "road condition";
|
||
En.MIXLY_LIFE_SUGGESTION_SHOPPING = "shopping";
|
||
En.MIXLY_LIFE_SUGGESTION_SPORT = "sport";
|
||
En.MIXLY_LIFE_SUGGESTION_SUNSCREEN = "sun protect";
|
||
En.MIXLY_LIFE_SUGGESTION_TRAFFIC = "traffic";
|
||
En.MIXLY_LIFE_SUGGESTION_TRAVEL = "travel";
|
||
En.MIXLY_LIFE_SUGGESTION_UMBRELLA = "umbrella";
|
||
En.MIXLY_LIFE_SUGGESTION_UV = "UV";
|
||
En.MIXLY_TIDE_DAILY_HEIGHT= "height of tide (cm)";
|
||
En.MIXLY_TIDE_DAILY_0_TIME= "Time of first low tide";
|
||
En.MIXLY_TIDE_DAILY_0_HEIGHT= "Height of first ebb (cm)";
|
||
En.MIXLY_TIDE_DAILY_1_TIME= "Time of first high tide";
|
||
En.MIXLY_TIDE_DAILY_1_HEIGHT= "Height of first high tide (cm)";
|
||
En.MIXLY_TIDE_DAILY_2_TIME= "Time of second low tide";
|
||
En.MIXLY_TIDE_DAILY_2_HEIGHT= "Second low tide height (cm)";
|
||
En.MIXLY_TIDE_DAILY_3_TIME= "Time of second high tide";
|
||
En.MIXLY_TIDE_DAILY_3_HEIGHT= "Second high tide height (cm)";
|
||
En.MIXLY_LOCATION_SEARCH_ID = "city ID";
|
||
En.MIXLY_LOCATION_SEARCH_NAME = "city name";
|
||
En.MIXLY_LOCATION_SEARCH_COUNTRY = "country code";
|
||
En.MIXLY_LOCATION_SEARCH_PATH = "Membership levels, from small to large";
|
||
En.MIXLY_LOCATION_SEARCH_TIMEZONE = "IANA Standard time zone name";
|
||
En.MIXLY_LOCATION_SEARCH_TIMEZONE_O = "The offset from the UTC time zone";
|
||
En.MIXLY_SUNRISE_T = "sunrise time";
|
||
En.MIXLY_SUNSET_T = "sunset time";
|
||
En.MIXLT_MOONRISE_T = "moonrise time";
|
||
En.MIXLY_MOONSET_T ="moonset time";
|
||
En.MIXLY_MOON_FRACTION = "The moon is illuminated in partial proportions, ranging from 0 to 1";
|
||
En.MIXLY_MOON_PHASE = "lunar phases，ranges from 0 to 1";
|
||
En.MIXLY_MOON_PHASE_NAME = "name of lunar phase";
|
||
En.MIXLY_DRAW_POINTER_DU = "(°)";
|
||
En.MIXLY_TEMPERATURE_UNIT_ = "(℃)";
|
||
En.MIXLY_PRESSURE_UNIT = "(hpa)";
|
||
En.MIXLY_PARAMETER_FREE = "all of the information（dictionary type）";
|
||
En.MIXLY_KEYBOARD = "keyboard";
|
||
En.MIXLY_IS_CONNECT = "whether be connected";
|
||
En.MIXLY_SEND_KEYBOARD = "send keyboard";
|
||
En.MIXLY_BATTERY ="battery level";
|
||
En.MIXLY_RANGE_OF_BATTERY = "the range of battery level is 0~100%";
|
||
En.MIXLY_MOUSE = "mouse";
|
||
En.MIXLY_SEND = "send";
|
||
En.MIXLY_VARIABLE_UNPACK = "Unpack";
|
||
En.MIXLY_TO_HEX = "Convert hexadecimal characters";
|
||
En.MIXLY_PYTHON_TOOLTIP_TOHEX = "Converts a value to a hexadecimal character";
|
||
En.MIXLY_RTC_GET_TIME_STR = "RTC gets the time string";
|
||
En.MIXLY_TIMESTAMP_TO_DATA ="convert to data";
|
||
En.MIXLY_TO_INDEX_SEQUENCE = "sequence number and content combine into an index sequence";
|
||
En.MIXLY_INDEX = "index";
|
||
En.MIXLY_TOTO_INDEX_SEQUENC_TOOLTIP = "Combine all the items and ordinals of the list into an index sequence, for example (0,'A') into one index sequence";
|
||
En.MIXLY_RGB_RAW = 'RGB color primitive value';
|
||
En.GET_IR_STRENGTH = 'get Infrared light';
|
||
En.MIXLY_RADAR = 'radar';
|
||
En.MIXlY_INTERACTION = 'reaction';
|
||
En.MIXLY_DETECTION_THRESHOLD ='detect threshold';
|
||
En.MIXLY_DELAY_TIME = 'delay time';
|
||
En.MIXLY_THRESHOLD_TOOLTIP = 'The larger the threshold, the closer the sensing distance';
|
||
En.MIXLY_DELAY_TIME_RANGE = 'The delay time range is 200ms～500ms';
|
||
En.MIXLY_GET_TO_INTERACTION ='get whether to trigger sensing';
|
||
En.MIXLY_MUSIC_PLAYER = 'Music player';
|
||
En.MIXLY_WHETHER ='whether';
|
||
En.MIXLY_STOPPED ='stopped';
|
||
En.MIXLY_PLAYING ='playing';
|
||
En.MIXLY_PAUSED = 'paused';
|
||
En.MIXLY_PLAYER_SET_VOLUME_TOOLTIP = 'The volume range is 0～30';
|
||
En.MIXLY_PLAYER_DIRECTORY_LOOP = 'directory loop';
|
||
En.MIXLY_PLAYER_SINGLE_STOP = 'single stop';
|
||
En.MIXLY_PLAYER_SEQUENTIAL_PLAY ='sequential play';
|
||
En.MIXLY_PLAYER_INSERT_MUSIC ='interjection';
|
||
En.MIXLY_COLOR_SENSOR = 'color sensor';
|
||
En.MIXLY_ALTITUDE_SENSOR = 'air pressure sensor';
|
||
En.MIXLY_TEMP_AND_HUMIDITY_SENSOR = 'temperature and humidity sensor';
|
||
En.MIXLY_LASER_RANGE_SENSOR = 'laser ranging sensor';
|
||
En.MIXLY_GEOMAGNETIC_SENSOR = 'geomagnetic sensor';
|
||
En.MIXLY_ENVIRONMENT_LIGHT = 'environment light';
|
||
En.MIXLY_NEXT = 'approach';
|
||
En.MIXLY_RADIO_FREQUENCY_READER = "radio frequency reader";
|
||
En.MIXLY_NINE_AXIS_SENSOR ='nine-axis sensor';
|
||
En.MIXLY_RADAR_SENSOR = 'microwave radar sensor';
|
||
En.MIXLY_PLAYER_PLAY_MUSIC_TOOTIP = 'Track input parameter:int type used to denote a song track(The sequence of tracks is the first to be placed on the USB flash drive.); str type used to represent the short file name of the song(Default mixly*.mp3, does not support Chinese, can be * omitted)';
|
||
En.MIXLY_DRIVER = 'driver';
|
||
En.MIXLY_IDENTIFY_ONCE_AND_SAVE = 'Identify once and save the result';
|
||
En.MIXLY_BE_IDENTIFIED = 'Identified?';
|
||
En.MIXLY_HELLO_XIAOZHI = 'Hello XiaoZhi(wakeword)';
|
||
En.MIXLY_XIAOZHIXIAOZHI = 'XiaoZhi XiaoZhi(wakeword)';
|
||
En.MIXLY_THE_FIRST = 'The first/user-defined';
|
||
En.MIXLY_THE_SECOND = 'The second/user-defined';
|
||
En.MIXLY_THE_THIRD = 'The third/user-defined';
|
||
En.MIXLY_THE_FOURTH = 'The fourth/user-defined';
|
||
En.MIXLY_THE_FIFTH = 'The fifth/user-defined';
|
||
En.MIXLY_THE_SIXTH = 'The sixth/user-defined';
|
||
En.MIXLY_THE_SEVENTH = 'The seventh/user-defined';
|
||
En.MIXLY_THE_EIGHTH = 'The eighth/user-defined';
|
||
En.MIXLY_THE_NINTH = 'The ninth/user-defined';
|
||
En.MIXLY_THE_TENTH = 'The tenth/user-defined';
|
||
En.MIXLY_THE_ELEVENTH = 'The eleventh/user-defined';
|
||
En.MIXLY_THE_TWELFTH = 'The twelfth/user-defined';
|
||
En.MIXLY_THE_13TH = 'The thirteenth/user-defined';
|
||
En.MIXLY_THE_14TH = 'The fourteenth/user-defined';
|
||
En.MIXLY_THE_15TH = 'The fifteenth/user-defined';
|
||
En.MIXLY_THE_16TH = 'The sixteenth/user-defined';
|
||
En.MIXLY_THE_17TH = 'The seventeenth/user-defined';
|
||
En.MIXLY_THE_18TH = 'The eighteenth/user-defined';
|
||
En.MIXLY_THE_19TH = 'The nineteenth/user-defined';
|
||
En.MIXLY_THE_20TH = 'The twentieth/user-defined';
|
||
En.MIXLY_Turn_on_the_lights = 'Turn on the lights';
|
||
En.MIXLY_Turn_off_the_lights = 'Turn off the lights';
|
||
En.MIXLY_Turn_up_the_brightness = 'Turn up the brightness';
|
||
En.MIXLY_Turn_down_the_brightness = 'Turn down the brightness';
|
||
En.MIXLY_Set_it_to_red = 'Set it to red';
|
||
En.MIXLY_Set_it_to_orange = 'Set it to orange';
|
||
En.MIXLY_Set_it_to_yellow = 'Set it to yellow';
|
||
En.MIXLY_Set_it_to_green = 'Set it to green';
|
||
En.MIXLY_Set_it_to_cyan = 'Set it to cyan';
|
||
En.MIXLY_Set_it_to_blue = 'Set it to blue';
|
||
En.MIXLY_Set_it_to_purple = 'Set it to purple';
|
||
En.MIXLY_Set_it_to_white = 'Set it to white';
|
||
En.MIXLY_Turn_on_the_fan = 'Turn on the fan';
|
||
En.MIXLY_Turn_off_the_fan = 'Turn off the fan';
|
||
En.MIXLY_First_gear = 'First gear';
|
||
En.MIXLY_Wind_speed_second = 'Second gear';
|
||
En.MIXLY_Third_gear = 'Third gear';
|
||
En.MIXLY_Previous = 'Previous';
|
||
En.MIXLY_Next_page = 'Next page';
|
||
En.MIXLY_Show_smiley_face = 'Show smiley face';
|
||
En.MIXLY_Show_crying_face = 'Show crying face';
|
||
En.MIXLY_Show_love = 'Show love';
|
||
En.MIXLY_Close_display = 'Close display';
|
||
En.MIXLY_Start_execution = 'Start execution';
|
||
En.MIXLY_Accelerate = 'Accelerate';
|
||
En.MIXLY_retard = 'Decelerate';
|
||
En.MIXLY_Query_temperature = 'Query temperature';
|
||
En.MIXLY_Query_humidity = 'Query humidity';
|
||
En.MIXLY_Query_brightness = 'Query brightness';
|
||
En.MIXLY_Query_sound = 'Query sound';
|
||
En.MIXLY_Query_time = 'Query time';
|
||
En.MIXLY_Query_distance = 'Query distance';
|
||
En.MIXLY_Query_pressure = 'Query pressure';
|
||
En.MIXLY_Query_key = 'Query key';
|
||
En.MIXLY_Query_touch = 'Query touch';
|
||
En.MIXLY_Query_color = 'Query color';
|
||
En.MIXLY_THE_RECOGNIZED_CMD = 'Recognized command word ID';
|
||
En.MIXLY_RECOGNIZED_STATE = 'Recognise the state whether be woken up';
|
||
En.MIXLY_WHETHER_BROADCAST = 'Recognise the state whether be reporting';
|
||
En.MIXLY_CI130X_GET_THE_RECOGNIZED_STATE_TOOLTIP = 'Returns a tuple (woken up or reporting), access via [0], [1]';
|
||
En.MIXLY_UNIT = 'Unit';
|
||
En.MIXLY_HYETAL = 'Rainfall';
|
||
En.MIXLY_BUTTON2 = 'Button';
|
||
En.MIXLY_PAY = 'Pay';
|
||
En.MIXLY_CARSH_CHANGE = 'Change';
|
||
En.MIXLY_COUNTDOWN = 'Countdown';
|
||
En.MIXLY_TIMING = 'Timing';
|
||
En.MIXLY_AT_THE_MOMENT = 'At the moment';
|
||
En.MIXLY_SHOW = 'Show';
|
||
En.MIXLY_LAMPLIGHT = 'Lamplight';
|
||
En.MIXLY_ACCELERATION = 'Acceleration';
|
||
En.MIXLY_RMB_UNIT = 'RMB';
|
||
En.MIXLY_GEAR = 'Gear';
|
||
En.MIXLY_LAYER = 'Layer';
|
||
En.MIXLY_GRAM = 'Gram';
|
||
En.MIXLY_METER = 'Meter';
|
||
En.MIXLY_CENTIMETER = 'Centimeter';
|
||
En.MIXLY_MILLIMETER = 'Millimeter';
|
||
En.MIXLY_LUMEN = 'Lumen';
|
||
En.MIXLY_DECIBEL = 'Decibel';
|
||
En.MIXLY_hectopascal = 'Hectopascal';
|
||
En.MIXLY_PERCENT = 'Percent';
|
||
En.MIXLY_METER_PER_SEC = 'Meter per second';
|
||
En.MIXLY_WRONG = 'Wrong';
|
||
En.MIXLY_GOOD = 'Good';
|
||
En.MIXLY_DECREASE = 'Decrease';
|
||
En.MIXLY_CMD = 'Command';
|
||
En.MIXLY_INCREASE_VOLUME = 'Increase Volume';
|
||
En.MIXLY_REDUCE_VOLUME = 'Reduce Volume';
|
||
En.MIXLY_MAX_VOLUME = 'Max Volume';
|
||
En.MIXLY_MINIMUM = 'Min Volume';
|
||
En.MIXLY_OPEN_RESPONSE = 'Open Response';
|
||
En.MIXLY_CLOSE_RESPONSE = 'Close Response';
|
||
En.MILXY_ENTER_WAKE_UP = 'Enter wake up';
|
||
En.MIXLY_QUIT_WAKE_UP = 'Quit wake up ';
|
||
En.MIXLY_CAR = 'Car';
|
||
En.MIXLY_LIGHT_SENSOR = 'Light Sensor';
|
||
En.MIXLY_BODY_SENSOR = 'Human Body Sensor';
|
||
En.MIXLY_SOILHUM_SENSOR = 'Soil Moisture Sensor';
|
||
En.MIXLY_GYROSCOPE_SENSOR = 'Gyroscope Sensor';
|
||
En.MIXLY_Horizontal_inclination = 'Horizontal Inclination';
|
||
En.MIXLY_Infrared_pyroelectric_sensor = 'Infrared Pyroelectric Sensor';
|
||
En.MIXLY_SERIAL_NUMBER = 'Serial Number';
|
||
En.MIXLY_BE_SHAKED = 'Shaken';
|
||
En.MIXLY_BE_CONNETCED = 'Connected';
|
||
En.MIXLY_AT = 'At';
|
||
En.MIXLY_SMARTCAMERA = 'Camera';
|
||
En.MIXLY_PROCCED = 'Proceed';
|
||
En.MIXLY_RECOGNIZED_RESULT = 'Recognition Result';
|
||
En.MIXLY_RFID_SCAN_OK = 'read the card';
|
||
En.MIXLY_RFID_SCAN_NOTAGERR = 'no card response';
|
||
En.MIXLY_RFID_SCAN_ERROR = 'card error';
|
||
En.MIXLY_WEIGH_SENSOR = 'Load cell';
|
||
En.MIXLY_Calibration_ratio = 'Calibration ratio';
|
||
En.MIXLY_KEYBOARD_AND_MOUSE = "keyboard and mouse ";
|
||
En.MIXLY_KEYBOARD_LIGHT = 'Keyboard Indicator Light';
|
||
En.MIXLY_NumLock = 'Num Lock';
|
||
En.MIXLY_CapsLock = 'Caps Lock';
|
||
En.MIXLY_ScorllLock = 'Scroll Lock';
|
||
En.MIXLY_CONNECT_OLLAMA = 'Connect to Ollama Platform';
|
||
En.MIXLY_CONNECT_OPENAI = 'Connect to OpenAI Platform';
|
||
En.MIXLY_SET_MAXIMUM_HISTORICAL_SESSIONS_NUM = 'Set Maximum Number of Historical Conversations to Retain';
|
||
En.MIXLY_LLM_CHAT = 'Chat with Large Language Model';
|
||
En.MIXLY_LLM_CONTENT_CALLBACK = 'Result Output Callback';
|
||
En.MIXLY_EMPTY_HISTORY = 'Clear History';
|
||
En.MIXLY_SET_RADIAN = 'convert radians';
|
||
En.MIXLY_TRANS_TO_ANGLE = 'to angles';
|
||
En.MIXLY_SET_DEGREE = 'convert angles';
|
||
En.MIXLY_TRANS_TO_RADIAN = 'to radians';
|
||
En.MIXLY_REF_TO_PRESSURE = 'Reference pressure';
|
||
En.MIXLY_CAL_TO_ALTITUDE = 'Calculate the altitude';
|
||
})();
|