diff --git a/legoresources/Block icns/Blockcolor-icns.pdf b/legoresources/Block icns/Blockcolor-icns.pdf new file mode 100644 index 00000000..d997847d Binary files /dev/null and b/legoresources/Block icns/Blockcolor-icns.pdf differ diff --git a/legoresources/Block icns/icn_block_Large_motor.svg b/legoresources/Block icns/icn_block_Large_motor.svg new file mode 100644 index 00000000..077f27f6 --- /dev/null +++ b/legoresources/Block icns/icn_block_Large_motor.svg @@ -0,0 +1,193 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_buttons_green.svg b/legoresources/Block icns/icn_block_buttons_green.svg new file mode 100644 index 00000000..340411e0 --- /dev/null +++ b/legoresources/Block icns/icn_block_buttons_green.svg @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_buttons_red.svg b/legoresources/Block icns/icn_block_buttons_red.svg new file mode 100644 index 00000000..2ee8752a --- /dev/null +++ b/legoresources/Block icns/icn_block_buttons_red.svg @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_buttons_yellow.svg b/legoresources/Block icns/icn_block_buttons_yellow.svg new file mode 100644 index 00000000..2a49a878 --- /dev/null +++ b/legoresources/Block icns/icn_block_buttons_yellow.svg @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_color_sensor.svg b/legoresources/Block icns/icn_block_color_sensor.svg new file mode 100644 index 00000000..96c0f1fa --- /dev/null +++ b/legoresources/Block icns/icn_block_color_sensor.svg @@ -0,0 +1,65 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_display.svg b/legoresources/Block icns/icn_block_display.svg new file mode 100644 index 00000000..fdcbe778 --- /dev/null +++ b/legoresources/Block icns/icn_block_display.svg @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_gyro.svg b/legoresources/Block icns/icn_block_gyro.svg new file mode 100644 index 00000000..5730d1c5 --- /dev/null +++ b/legoresources/Block icns/icn_block_gyro.svg @@ -0,0 +1,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_medium_motor.svg b/legoresources/Block icns/icn_block_medium_motor.svg new file mode 100644 index 00000000..cdb56b26 --- /dev/null +++ b/legoresources/Block icns/icn_block_medium_motor.svg @@ -0,0 +1,65 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_touch_sensor.svg b/legoresources/Block icns/icn_block_touch_sensor.svg new file mode 100644 index 00000000..25e8163f --- /dev/null +++ b/legoresources/Block icns/icn_block_touch_sensor.svg @@ -0,0 +1,84 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/Block icns/icn_block_ultra_sonic.svg b/legoresources/Block icns/icn_block_ultra_sonic.svg new file mode 100644 index 00000000..31f0df26 --- /dev/null +++ b/legoresources/Block icns/icn_block_ultra_sonic.svg @@ -0,0 +1,103 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/.DS_Store b/legoresources/SVGassets/.DS_Store new file mode 100644 index 00000000..5008ddfc Binary files /dev/null and b/legoresources/SVGassets/.DS_Store differ diff --git a/legoresources/SVGassets/Color Sensor.svg b/legoresources/SVGassets/Color Sensor.svg new file mode 100644 index 00000000..45efd1fd --- /dev/null +++ b/legoresources/SVGassets/Color Sensor.svg @@ -0,0 +1,246 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/EV3.svg b/legoresources/SVGassets/EV3.svg new file mode 100644 index 00000000..b1259fc7 --- /dev/null +++ b/legoresources/SVGassets/EV3.svg @@ -0,0 +1,146 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/Large Motor.png b/legoresources/SVGassets/Large Motor.png new file mode 100644 index 00000000..32bf7796 Binary files /dev/null and b/legoresources/SVGassets/Large Motor.png differ diff --git a/legoresources/SVGassets/Large Motor.svg b/legoresources/SVGassets/Large Motor.svg new file mode 100644 index 00000000..ee3d43a7 --- /dev/null +++ b/legoresources/SVGassets/Large Motor.svg @@ -0,0 +1,650 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/Medium Motor.svg b/legoresources/SVGassets/Medium Motor.svg new file mode 100644 index 00000000..1c45a248 --- /dev/null +++ b/legoresources/SVGassets/Medium Motor.svg @@ -0,0 +1,220 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/Touch sensor.svg b/legoresources/SVGassets/Touch sensor.svg new file mode 100644 index 00000000..130a40b9 --- /dev/null +++ b/legoresources/SVGassets/Touch sensor.svg @@ -0,0 +1,347 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/brickbuttons.svg b/legoresources/SVGassets/brickbuttons.svg new file mode 100644 index 00000000..d55c25c7 --- /dev/null +++ b/legoresources/SVGassets/brickbuttons.svg @@ -0,0 +1,138 @@ + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/color overview/LEGO-MakeCode-Colors.pdf b/legoresources/SVGassets/color overview/LEGO-MakeCode-Colors.pdf new file mode 100644 index 00000000..bc659245 Binary files /dev/null and b/legoresources/SVGassets/color overview/LEGO-MakeCode-Colors.pdf differ diff --git a/legoresources/SVGassets/gyro.svg b/legoresources/SVGassets/gyro.svg new file mode 100644 index 00000000..629039cf --- /dev/null +++ b/legoresources/SVGassets/gyro.svg @@ -0,0 +1,308 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/icn_port.svg b/legoresources/SVGassets/icn_port.svg new file mode 100644 index 00000000..64b2aad2 --- /dev/null +++ b/legoresources/SVGassets/icn_port.svg @@ -0,0 +1,89 @@ + + + + + + image/svg+xml + + + + + + + + + + + + B + diff --git a/legoresources/SVGassets/screen.svg b/legoresources/SVGassets/screen.svg new file mode 100644 index 00000000..9e5b21fb --- /dev/null +++ b/legoresources/SVGassets/screen.svg @@ -0,0 +1,166 @@ + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + diff --git a/legoresources/SVGassets/trash.svg b/legoresources/SVGassets/trash.svg new file mode 100644 index 00000000..38d77825 --- /dev/null +++ b/legoresources/SVGassets/trash.svg @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/legoresources/SVGassets/ultra sonic.svg b/legoresources/SVGassets/ultra sonic.svg new file mode 100644 index 00000000..55887dd3 --- /dev/null +++ b/legoresources/SVGassets/ultra sonic.svg @@ -0,0 +1,535 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libs/color-sensor/_locales/color-sensor-strings.json b/libs/color-sensor/_locales/color-sensor-strings.json index bfa0eca8..5c52059d 100644 --- a/libs/color-sensor/_locales/color-sensor-strings.json +++ b/libs/color-sensor/_locales/color-sensor-strings.json @@ -13,8 +13,8 @@ "LightCondition.Dark|block": "dark", "LightIntensityMode.Ambient|block": "ambient light", "LightIntensityMode.Reflected|block": "reflected light", - "sensors.ColorSensor.color|block": "`icons.colorSensor` %color| color", - "sensors.ColorSensor.light|block": "`icons.colorSensor` %color|%mode", + "sensors.ColorSensor.color|block": "`icons.colorSensor` %sensor| color", + "sensors.ColorSensor.light|block": "`icons.colorSensor` %sensor|%mode", "sensors.ColorSensor.onColorDetected|block": "on `icons.colorSensor` %sensor|detected color %color", "sensors.ColorSensor.onLightChanged|block": "on `icons.colorSensor` %sensor|%mode|%condition", "sensors.color1|block": "1", diff --git a/libs/color-sensor/color.ts b/libs/color-sensor/color.ts index 708ea066..0638c5c3 100644 --- a/libs/color-sensor/color.ts +++ b/libs/color-sensor/color.ts @@ -100,6 +100,8 @@ namespace sensors { //% block="on `icons.colorSensor` %sensor|detected color %color" //% blockId=colorOnColorDetected //% parts="colorsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=100 blockGap=8 //% group="Color Sensor" @@ -113,12 +115,14 @@ namespace sensors { /** * Get the current color from the color sensor. - * @param color the color sensor to query the request + * @param sensor the color sensor to query the request */ //% help=sensors/color-sensor/color - //% block="`icons.colorSensor` %color| color" + //% block="`icons.colorSensor` %sensor| color" //% blockId=colorGetColor //% parts="colorsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=99 //% group="Color Sensor" @@ -136,6 +140,8 @@ namespace sensors { //% block="on `icons.colorSensor` %sensor|%mode|%condition" //% blockId=colorOnLightChanged //% parts="colorsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=89 blockGap=8 //% group="Color Sensor" @@ -146,12 +152,14 @@ namespace sensors { /** * Measures the ambient or reflected light value from 0 (darkest) to 100 (brightest). - * @param color the color sensor port + * @param sensor the color sensor port */ //% help=sensors/color-sensor/light - //% block="`icons.colorSensor` %color|%mode" + //% block="`icons.colorSensor` %sensor|%mode" //% blockId=colorLight //% parts="colorsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=88 //% group="Color Sensor" @@ -171,15 +179,15 @@ namespace sensors { } } - //% whenUsed block="1" weight=95 fixedInstance + //% whenUsed block="1" weight=95 fixedInstance jres=icons.port1 export const color1: ColorSensor = new ColorSensor(1) - //% whenUsed block="3" weight=90 fixedInstance + //% whenUsed block="3" weight=90 fixedInstance jres=icons.port3 export const color3: ColorSensor = new ColorSensor(3) - //% whenUsed block="2" weight=90 fixedInstance + //% whenUsed block="2" weight=90 fixedInstance jres=icons.port2 export const color2: ColorSensor = new ColorSensor(2) - //% whenUsed block="4" weight=90 fixedInstance + //% whenUsed block="4" weight=90 fixedInstance jres=icons.port4 export const color4: ColorSensor = new ColorSensor(4) } diff --git a/libs/core/_locales/core-jsdoc-strings.json b/libs/core/_locales/core-jsdoc-strings.json index d59f4270..e546c150 100644 --- a/libs/core/_locales/core-jsdoc-strings.json +++ b/libs/core/_locales/core-jsdoc-strings.json @@ -55,12 +55,12 @@ "motors.Motor.move": "Moves the motor by a number of degrees", "motors.Motor.move|param|angle": "the degrees to rotate, eg: 360", "motors.Motor.move|param|power": "the power from ``100`` full forward to ``-100`` full backward, eg: 50", - "motors.Motor.power": "Sets the motor power level from ``-100`` to ``100``.", - "motors.Motor.power|param|power": "the power from ``100`` full forward to ``-100`` full backward, eg: 50", "motors.Motor.reset": "Resets the motor.", "motors.Motor.setBrake": "Sets the automatic brake on or off when the motor is off", "motors.Motor.setBrake|param|brake": "a value indicating if the motor should break when off", "motors.Motor.setReversed": "Reverses the motor polarity", + "motors.Motor.setSpeed": "Sets the motor speed level from ``-100`` to ``100``.", + "motors.Motor.setSpeed|param|speed": "the power from ``100`` full forward to ``-100`` full backward, eg: 50", "motors.Motor.speed": "Gets motor actual speed.", "motors.Motor.stop": "Stops the motor", "motors.Motor.tachoCount": "Gets motor tacho count.", diff --git a/libs/core/_locales/core-strings.json b/libs/core/_locales/core-strings.json index 2f10e924..76ee79a4 100644 --- a/libs/core/_locales/core-strings.json +++ b/libs/core/_locales/core-strings.json @@ -37,9 +37,9 @@ "control|block": "control", "motors.Motor.count|block": "`icons.motorLarge` %motor|count", "motors.Motor.move|block": "move `icons.motorLarge` %motor|by %angle|degrees at %power|%", - "motors.Motor.power|block": "power `icons.motorLarge` %motor|to %power|%", "motors.Motor.setBrake|block": "set `icons.motorLarge` %motor|brake %brake", "motors.Motor.setReversed|block": "set `icons.motorLarge` %motor|reversed %reversed", + "motors.Motor.setSpeed|block": "set speed `icons.motorLarge` %motor|to %speed|%", "motors.Motor.speed|block": "`icons.motorLarge` %motor|speed", "motors.Motor.stop|block": "stop `icons.motorLarge` %motor", "motors.Motor.tachoCount|block": "`icons.motorLarge` %motor|tacho count", diff --git a/libs/core/icons.jres b/libs/core/icons.jres index be203f27..03a5e0a5 100644 --- a/libs/core/icons.jres +++ b/libs/core/icons.jres @@ -4,30 +4,51 @@ "dataEncoding": "base64" }, "ultrasonicSensor": { - "icon": "data:image/png;base64,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" + "icon": "data:image/png;base64,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" }, "infraredSensor": { "icon": "data:image/png;base64,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" }, "motorMedium": { - "icon": "data:image/png;base64,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" + "icon": "data:image/png;base64,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" }, "motorLarge": { - "icon": "data:image/png;base64,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" + "icon": "data:image/png;base64,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" }, "touchSensor": { - "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACIAAAAiCAYAAAA6RwvCAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHgg/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7iJIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKSKcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8//UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBCCmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHaiAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyGvEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPEbDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKggHCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmxpFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+IoUspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgXaPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1QwNzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnUlqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIpG6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acKpxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsMzhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZLTepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnutrxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFnYhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPjthPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGLw34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8YuZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhOOJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCepkLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQrAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0dWOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWFfevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebeLZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ27tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHtxwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTradox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLTk2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9DBY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAACFNJREFUeNqsmFtsXFcVhr99OWdutmfGlzhO3MZJ41Y0adIq6VVF4vKAQIKHQhFCqigSQrxVArWVeKAgJKhAqEhUUBA3AapKSy+Jk7S0NE0qWhLAqeM4tAmO6/oyTuzM2LE9c2bOOXtvHmbsxk3SxqHraS5nb/17r3+t9f9HlMuVV4UQaa2V09pDCC4WCpgD/gw8Diyc/2epNMuBAweQUiKl5HLCOYeUkq6uLhKJBBq4zTnnRVGMMRbP0yilLrX+48CXgB8CL/IhhgTCpS/WWmq1kDAMsdZdas3HgF3AL4ANHxqQ808vhEBrjVIaKcX7rUsC3wBeAb4upUz+v0B0GIYkEgniOKZWqxEEATMzM4yPTzA6OkqxWKS3dzM9PT1IKRFCLKfP87yNnuf9MoqiL0spv9cAdkUhJiYKi6l0MqOkZO/e53n99dcolytEUUgUxURRBEBv72a2b99ONpulWq1irV2+xcZNVoUQjwGPAGOrJauYLEwtWmsyWmmMNRzpP8L+/fuZm5tDKbXMm0qlQnNzMzt23ERv77UIIYjjGOcu4NJbwI+A360aiHMu45xFKU0mnWZ6epoXX/wr/f1HiOMYKRVRFBEEFaIoZsOGDdxyy810dnYSRRFxHCMurPs+4PvAv1YFBBzOOay1JPwEiYTP4OAx9u17nvHxcbTWWGsIw4hyuYzve9x4401s23YDqVSKMAwvdjvngJ8DPwWmVwWkDqa+YXNThkoQ8Mr+Vzh48CDlchmlNMYYgiCgWq3S2bmG22+/nZ6eHpxzy5x6TwwBPwCeBMxlA3Gu/qCzFu15NDVleHtkhL6+PQwNHUepevcMwzp3nIMtWz7CrbfeRi6Xo1qt4py7WLqeAh4GjqwKCM5hG+nKZNKA4PChQ+zbt4+ZmRm09nCuTuZyeYGWlix33vlRtm27oVFZjqV9z4tpIcTPnHOPSinn1q1bd5lAAJzFWodUiuamJkrFInv27OHQocPEcdQgc0i5XCGOY+699yvs3LmTxcVFjDEYY4jjGGMM1lqstRhjBoCHOjs7+5LJpLtsIEu/WWNIJBOk0xkGjx5l9+5djI1NIGW9nOfnF7jmmk08+OD97+4DGGMbe1uMsUsAjdbqm0qpPr3qmSAl1VqNWjXk+i1b8H2Pp59+hvHxiXr5Z9IUi0WKxVna2loxxiIEy7wSQi83Queccs7dD26TvqJ2LAQ4x/z8PJlME+vWdTE5WUBKibUGrX0WFhZQSi2TdkkiLI0JKcVSV+4Gdl4REBwgBM5agqDMxESBZDKBc/VK6uhoIwgCgiBYAUJJiVj6rNQKYFcGRICzjoTv8c474ywuLpBIJIiiCN/32bz5GqIoIorqCkP5PsZTmChGxwYBCCERAqRUE0KIgSsC4pzD9zyccwwPD+P7PkIIoiims7OD9evX45ytn9bzqI1N0D45g+jpZrarA+IIZ02DxKYP+MMVpyabzXL8+BDFYpFkMkUcx/i+x8aNG/F9nyiK6mlQiv8+28fkq69xT76bkc9/ivHPfhIV1ADmgceAQbnKjGCdI5FIkEolGRoawvM8fN9HKUk+n6erqwtj6qeVnqY8Nk6pf4BR6ygUp7jq2ZfQ58pQr6LngMElqbgqjlpraWttZWJinKmpKTKZNJ6nUErS3d1NormZSEmM1ohUmtOvvkZtYQ7jJzihkqRmztJycgTj+1Wse6TRbJBaqw+ShSu4kfB9Uqkk/f1HUEqjtYeUkpZslra2VuzJEVpL8ySDKqUnnsH1vUTeS+OAU8JQI6L98CDW00+SaxkUrTlozaFPvnWCnk31vIZh1Dj3JYBYR74jT6FQoFAokE6niGODMTFru9dTmyjQ//BP+EJ3L9s71nL8zTepGMcazyNhLWexTKBYf2RofuzM2V+fPvB368YLCK3Rw6eG/WKpyLXXXUc+34oxdVtxketAe5pMJsOhfxzCOfB9HwhRKkNraxv/efxpgtnTJGdjpBxlaz5LR1Mbb1TO1f2Slpw2kq0zJU/f953s2flZfBsCAnX33Xd/sVKprDlz5gwmNmRz2YYIssu8gLpGac3nCSoV+vv/jVISISTWOlpaWmhqbmJxcYFNI1PsrAQYJ4mCCk3VmKusJAZSQtCOIBLCWwxqO6zWh/M6WWhSPuquu+56QUrZZq3dVioWmZ2bI5NOk0ln6gAag0oIyZr2do4NHWN6ehqv0UeklORyWQSQu66X5pt3UMtlccNjZKIYhUA6WG8FGsFhP2ZEW7Yar32rUXs3WHniaiuRwNvAPVLKr2nPm5ybnWVg4A1GTp3COoduzIt8LkslqDA6Olq3iLpuKTKZFFprnLVQCYiu6uLEJ+7g917IX2SNk9LiGi7upGeJBCgHWcdUEv6pHXhuZfn+Bvi01nqftZZTI8MMHh1gYf4cWntEUczQ0BC1Wm3ZQvi+TzKZWh71zjmUg+ILL7NwrshRD36rq/xKV5kUhrJwJBHsjHWYcuLhEKYtYOGCWXMM+JwQ4gGt9QPFYjFXLpfJNDUxWyoB4Hneu+5M6xWmWyZ8gtNnmPzby0BIpibRWIrALEluDtPGOt7uNuJbBnavcHoXqVLTMNkHPc/7cRzHd8yWShcY87rj81bo0rrGgA237KCtME3eKZL5VtTaTjzfH7j6T899N0a9YXFj720S7zdrXgc+I4T4tlLqPiCx/I5CSeK4ruQvsAhJn86v3oOuhQQOFpM+sZLEbbmHnBC7r/3jE1hSF3rfD2im54AHgQMNO3AjQLlcoVgsXcpY1bVKo1s762Y9qR5tbb5+b21tOwJ7cRN+mWPmIPCUEMJaa/1yuWKDILiYoTo/Ko1rekcmkruEc0bE5pIP/28AnxuQSa73CAEAAAAASUVORK5CYII=" + "icon": "data:image/png;base64,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" }, "gyroSensor": { - "icon": "data:image/png;base64,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" + "icon": "data:image/png;base64,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" }, "colorSensor": { - "icon": "data:image/png;base64,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" + "icon": "data:image/png;base64,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" }, "brickButtons": { - "icon": "data:image/png;base64,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" + "icon": "data:image/png;base64,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" }, "brickDisplay": { - "icon": "data:image/png;base64,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" + "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABbCAYAAACFziAsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAOxAAADsQBlSsOGwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAPASURBVHic7d3Bb9tUAMfx37OdkfZQ2k5p2jKUSZ24MG3SJoaUtkPAKYccEdmBEwck/gckV+JfGOWGhLZpHSDtNCH1sokibTtwSsQ6UdZoUZWom9Z2xQwn6uMyJqBeanA7/5L9Prfmxc8v/qqJo6aOWVhYKFvYLwFMQtK0BotPHMWgMWmMmXegGDQs7BEn7UXIPykIGQUhoyBkFISMgpBREDLef7lzs9lE434DYTs8qPX0Fc/zkM/nUSgU4m8T507WWty4fgPVavV/L+5lVjhaQKlUguftfbhjBalWq11jjL8+gcmjR+DG2GG/evxoE7/U7qLT7uwaq6/WcevmLUzPTO85T6wjWKvWnjt2/K0TePv9aRhj4kzV146fOYmrX30TGaVWq6E4XdzzOMV6UQ+CIPJ2YwxOz55RjKeGD4/g2JtvRI6FYYh2u73nHInOsrKDWWReOZRkir4zNPpqou0TnvbqN2O/6X0IGQUhoyBkFISMgpBREDIKQkZByCgIGQUhoyBkFISMgpBREDIKQkZByCgIGQUhoyBkFISMgpBREDIKQkZByCgIGQUhoyBkFISMgpBREDIKQkZByCgIGQUhoyBkFISMgpBREDKJgtidnf1aR9+wOzbR9rGCuJ4befuT359ge+txogX0mwfN9cjbjTFw3ejj+Hexgoznx587tnTtOsI/dLkmALh3ZwWry79GjuVyuVhBYl18plgsol6vIwx3H/jGvfu4Mn8Buck8vMzLezWgrUebeNh6EDnmOA5mz87GmsdcXrgc60lvY2MDSz8sodFooNPZfbUb2c11XYyNjWFmdgb5fD7WNrGDsFq+s4zFxUUAwNSxKZRKpZRXlIxOe8koCBkFIaMgZBSEjIKQURAyCkJGQcgoCBkFIaMgZLw4l79mFgQBRkZGAACOcWJdzpuZt74e/ReuXjEwMIDR0VEAwPDwMHr98Xhbm1tpryERYwxyuRwAYHBwEL3+ePQaQsYB8Fvai5Bnth0AX6S9CnnmvAEA3/dPGWOm/j2azWaHJl6b+Pig9h5sB7dbrdaPCad5x1pbBgBjzAqA+eQre/GstSu+7//U9QtALn53seB23NUDWwTs5+c+PPdZkjnm5uY+stZ+/fTHb33f/2AflpYavaiTURAyCkJGQcik+dnPprHmUtJJMpnM92EY/vWNjdGf5ewhaZ1lNWHxXqVS+fkA5u5paTxlKUYXLzpISzG66xpk6NDQOoD9+uePNVicVYzuugYpl8uBNfZTC/sw4X7WYPFupVK5m3Cevvcnrxny0mmZOMwAAAAASUVORK5CYII=" + }, + "port1": { + "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAYAAADimHc4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAYDQAAGA0BpVFbVgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAARFSURBVHic7dzPT9p3HMfxF79hCEhFv7FjJRITzBqT9aTpTl3S6alLTBdTdun+iO5f8eB68DCyxpMkZjazyRpPXjxpzRqjCaVGv2PIvogF+S7fHUy/la6CyFde7df34wafL1/eX5/6hXwxOFRVNSBonOwBrjoJQCYByNzsAayUe5XD/v6+pfuMfx7H4OCgpfs8zVYBqtUqyuWypfusHdcs3d/75BREJgHIJACZBCCTAGQSgEwCkEkAMglAJgHIJACZBCCz1cW4y6BpGl7vvj5z3efzIdYXu/D+P6kAmqZhY2PjzPW6Xrf8OQuFAgqFwpnr16LXrk4A/V8db6pv2GNYSl4DyCQAmQQgkwBkEoBMApB9Um9DrVT8u4jSP6WG+yKRCPr6+ro6x5ULUCwWkc1msfz7MnRdb1ibnJzEwx8fdnWeKxPg8PAQ2WwWS78t4fj4mD2OqaMA9Xod29vbVs3S0kX+SapWq+Hp0lMsLCygUqlcwlSd6SiArutNL1Qx6bqO5388x/z8PEqlUusHkNjuFGQYBlZXV5H5JQNVVdnjtGSbAIZhYG1tDU9+fYJcLsce59xsEWBrawuPf36MnZ2dptt5PB7c/fYuyloZKysrXZquOVsE0HW96Q/f4XBgbGwMD9IPoCgK5ubmujhdc7YIMDIygmQy+cF3ZKOjo0j/kMbQ0BBhstZsEQAAJiYmMDMzY96Ox+O4//19jI+PE6dqzTYBbn99G5lMBm63G1NTU7jzzR04nR//pS7bBPB4PHj00yMkEgl4PB72OOdmmwAAMDw8zB6hbR//36jNSQAyCUAmAcgkAJkEIJMAZBKATAKQSQAyCUAmAcgkAJkEIJMAZBKATAKQSQAyCUAmAcgkAJkEIJMAZLb5v6Dd3V0sLi6ea9uXf7784P3r6+uYnZ1t+thwOIzp6em25zuLbQIcFA/wbPlZR/vI5/PI5/NNt1EUxdIAcgoikwBkEoDMNq8Bsf4Y7n1379KfJ9QTsnR/tgmgKArS6TR7jLbJKYhMApBJADIJQNbRi7DT6UQ0Gm25jcvlarhP0zRUq1XzdjgcNt9dqH+pqNffff9nf6wfXq/3f2vBYBC9kV4AQOWo0vB9ENcHr8PhcAAAyodlaJpmrimKArfr5LAPSgc4Ojoy17xeL4LB4DmP/kRPqKet7d/XUQCfz4dbX91q+3EvNl9gb2/PvD0wMIAbX9wAAGhlrSFAIpFAOBwGAJRKJXOtN9KLVCoF4OQ60OkAqVTKDJB7lWsIkBxKIhAIAAA2NzcbAkSjUdz88mbbx9MJOQWRSQAyCUAmAcgkAJkEIJMAZBKATAKQSQAyygcyfr8fodC7T5beXusBgOBnjddiTl9HCvYE4XSd/M74A/6Gx5/en2EY5qUIn9fXsPb2fuDkO4YC/oB52+f1XfiYLsqhqqrR9WcVJjkFkUkAMglAJgHIJACZBCCTAGT/AVajE7I72JDGAAAAAElFTkSuQmCC" + }, + "port2": { + "icon": "data:image/png;base64,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" + }, + "port3": { + "icon": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAYAAADimHc4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAYDQAAGA0BpVFbVgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAb6SURBVHic7ZztT1NXHMe/fby0t61tBSqOCsWQIg+KhIHGJcLcK4gs4YWLiTMx4gtxyXQume6fcCRjr4wvTZxIYPJGZiRREwzL0JgBq4lG6KiAUOFeyi3cFvYCrX24lYfe6wnX83nXc+45v1M+5dxzz8PVTE1NrYBCDC3pBnzqUAGEoQIIoyfdADkZ849hcnJS1jrzP8tHXl6erHXGoyoB4XAYPM/LWufi0qKs9SVDuyDCUAGEoQIIQwUQhgogDBVAGCqAMFQAYagAwlABhKECCEMFEEZVk3FKwHEcxgPjafMZhkH29uxN17+lBHAch6GhobT5YkSUPeb09DSmp6fT5jsdzk9HQCQagRAWSDdDVug9gDBUAGGoAMJQAYShAghDBRBmSw1DN4ooihgfH8fU1BSmX0+D4zkIggANNDCZTTCbzMjOycbuot3IdeUSaaOqBIiiiJGRETx+/Bi+f30YHR1FNBpdV1mr1Yrqz6tx+PBheL1eaDQahVu7iqoE3Oq4ha6urk2V5Xkefff60HevD16vFy1nWuB2u2VuYSoZCRBFES9evJCrLWui9Capd/h8Plz66RJaW1tx6ItDisbKSEAkEvngRNVWJhqNor29HXq9HrUHahWLo6ouKB69Xg+PxwOPx4MdeTvgcrnAMAzMZjMEQcBCaAH+//wY+mcIw8PDWFlJPSaxvLyMq1evorSsFFarVZF2ajI5oCEIAvof9cvZnozo7e3FxMQEqqqq4PV6YTAY1lVu4tUErl27hqdPn0rmNzQ24OTJk5J5TocTlZWVm26zqgRkwvLyMq5cuYK/Bv5KyXM6nWj/rV1yZJSpAPog9hatVovTp0+DYZiUvGAwCL/fr0xcRWrdotjtdpRXlEvmfWhRJhOogCQ8hR7J9LnZOUXiUQFJWCwWyXS9QZkBIxWQRCgUkky32+2KxKMCkggEAilpGo0GRUVFisSjAuIQRRFPnjxJSS8tKwXLsorEpALi6LndI9kFNTY2KhaTCnjL4OAgOjo6UtJrampQVVWlWFzVzgWtl8XFRXR3d6O7qztl7aCwsBBnW88qGl/VAnieh7CQuJFLjIiYn5/H5OQknvmeob+/X7LbKS0txcUfL8JkMinaRlUL6O7qRk9Pz4bKMAyD5uZmHG06Cq1W+R5a1QI2CsuyaDnTgurq6o/yxweogARCoRDafmmD1WpFXX0dmpqaFFsHeAcdBUnA8zxu/3Eb578/jwcPHigaS9X/AbUHalPedBKNRhEOh8FxHAKBAF6OvkRwJihZPhQKof3XdrwKvMKxb44p0kZVCyguLkZxcfGa1/n9fjx8+BC9d3ohCKnb3zs7O2GxWNDQ2CB7G2kXBMDtduP48eNoa2tDRUWF5DXXr19HYDx1nihTqIA4bNtsuPzzZezbty8lLxKJ4MbvN2SPSQUkodVqce67czAajSl5g38Ppp2u3nQ8WWtTCTabDTU1NSnpSmxEowLSsKtgl2R6MCg9YtosVEAaWLP0/L9Op5M1DhWQhrk56UV4p9MpaxwqIA2jo6OS6Tk5ObLGoQIkCIfDktsU8/PzqYCPQeetTskn4oMHD8oeiwpI4v79+5JrCEajEfX19bLHU/Vc0EaYn5/HzZs30XunV3KrenNzM5zb5b0BAyoS4PP5EIlEkJubC6fTua7hIs/zeP78OR71P8LAwAAWFhYkr9u7dy+avm6Su8kAVCTg7p93Y3P3Op0ODocDLMvCYDDAZDKBYRisYAVLi0sIhUKYmZlJO9SMp6SkBBd+uKDYCplqBMQTjUbXfM3Meqj/sh6nTp2SnBeSC1UKyBS3240T356QnBWVGyrgLXq9HtXV1Tjy1RGUl5fTc8Ibpay8DIIgIBgMIhgMYnZ2Nu21JpMJLMvCtcMFt9uNPSV7FD2I9yFUI6Curg51dXUJae/Wf0VRxNLiEsysGSzLfrRf93pQjQApdDqdYrua5YI+CROGCiAMFUCYjO4BWq0WDodjzWuSpwU4jkM4HI59ttlssFpWRyBTr6cgiu/f/5mTnRN7EIrPY1kW9m2r57ZCC6GEUc/OvJ2xGy0/z4PjuFiey+WCXrf6td/MvkmYfjAajRu+Z1is0of61ktGAhiGwf7K/RsuNzwyjImJidjn3Nxc7HKvrsFyPJcgoKCgADabDQAwOzsby7Nvs8Pr9QJYPdcVLyD+fT9j/rEEAUWeotiW85GRkQQBDocDZaVlG/4+mUC7IMJQAYShAghDBRCGCiAMFUAYKoAwVABhqADCUAGEIbIekJWVlbD6FL/onbwrOX4eibWw0OpWfzNZpqyE8vH1raysxKYiGCOTkBe/GGMwGGDKen8SnjGmvi9OaTJ6ayIlc2gXRBgqgDBUAGGoAMJQAYShAghDBRDmfwiUKR0LmCC0AAAAAElFTkSuQmCC" + }, + "port4": { + "icon": "data:image/png;base64,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" + }, + "portA": { + "icon": "data:image/png;base64,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" + }, + "portB": { + "icon": "data:image/png;base64,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" + }, + "portC": { + "icon": "data:image/png;base64,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" } } \ No newline at end of file diff --git a/libs/core/jres/icons/brickButtons-icon.png b/libs/core/jres/icons/brickButtons-icon.png index cb389b30..bac5b745 100644 Binary files a/libs/core/jres/icons/brickButtons-icon.png and b/libs/core/jres/icons/brickButtons-icon.png differ diff --git a/libs/core/jres/icons/brickDisplay-icon.png b/libs/core/jres/icons/brickDisplay-icon.png index 9e7bded6..9f7dcfa4 100644 Binary files a/libs/core/jres/icons/brickDisplay-icon.png and b/libs/core/jres/icons/brickDisplay-icon.png differ diff --git a/libs/core/jres/icons/colorSensor-icon.png b/libs/core/jres/icons/colorSensor-icon.png index 82c7cf03..ec2316c6 100644 Binary files a/libs/core/jres/icons/colorSensor-icon.png and b/libs/core/jres/icons/colorSensor-icon.png differ diff --git a/libs/core/jres/icons/gyroSensor-icon.png b/libs/core/jres/icons/gyroSensor-icon.png index 0f5cc8a9..c77946d2 100644 Binary files a/libs/core/jres/icons/gyroSensor-icon.png and b/libs/core/jres/icons/gyroSensor-icon.png differ diff --git a/libs/core/jres/icons/motorLarge-icon.png b/libs/core/jres/icons/motorLarge-icon.png index 4ec112b8..32bf7796 100644 Binary files a/libs/core/jres/icons/motorLarge-icon.png and b/libs/core/jres/icons/motorLarge-icon.png differ diff --git a/libs/core/jres/icons/motorMedium-icon.png b/libs/core/jres/icons/motorMedium-icon.png index 5793cfd1..50591820 100644 Binary files a/libs/core/jres/icons/motorMedium-icon.png and b/libs/core/jres/icons/motorMedium-icon.png differ diff --git a/libs/core/jres/icons/port1-icon.png b/libs/core/jres/icons/port1-icon.png new file mode 100644 index 00000000..1699b190 Binary files /dev/null and b/libs/core/jres/icons/port1-icon.png differ diff --git a/libs/core/jres/icons/port2-icon.png b/libs/core/jres/icons/port2-icon.png new file mode 100644 index 00000000..2f882383 Binary files /dev/null and b/libs/core/jres/icons/port2-icon.png differ diff --git a/libs/core/jres/icons/port3-icon.png b/libs/core/jres/icons/port3-icon.png new file mode 100644 index 00000000..7f5a77c0 Binary files /dev/null and b/libs/core/jres/icons/port3-icon.png differ diff --git a/libs/core/jres/icons/port4-icon.png b/libs/core/jres/icons/port4-icon.png new file mode 100644 index 00000000..b3af98bd Binary files /dev/null and b/libs/core/jres/icons/port4-icon.png differ diff --git a/libs/core/jres/icons/portA-icon.png b/libs/core/jres/icons/portA-icon.png new file mode 100644 index 00000000..c9550307 Binary files /dev/null and b/libs/core/jres/icons/portA-icon.png differ diff --git a/libs/core/jres/icons/portB-icon.png b/libs/core/jres/icons/portB-icon.png new file mode 100644 index 00000000..d5112f5d Binary files /dev/null and b/libs/core/jres/icons/portB-icon.png differ diff --git a/libs/core/jres/icons/portC-icon.png b/libs/core/jres/icons/portC-icon.png new file mode 100644 index 00000000..628b2410 Binary files /dev/null and b/libs/core/jres/icons/portC-icon.png differ diff --git a/libs/core/jres/icons/portD-icon.png b/libs/core/jres/icons/portD-icon.png new file mode 100644 index 00000000..3122fd14 Binary files /dev/null and b/libs/core/jres/icons/portD-icon.png differ diff --git a/libs/core/jres/icons/touchSensor-icon.png b/libs/core/jres/icons/touchSensor-icon.png index 8a34d505..f6d22e41 100644 Binary files a/libs/core/jres/icons/touchSensor-icon.png and b/libs/core/jres/icons/touchSensor-icon.png differ diff --git a/libs/core/jres/icons/ultrasonicSensor-icon.png b/libs/core/jres/icons/ultrasonicSensor-icon.png index 82d6c1e0..0429a7d7 100644 Binary files a/libs/core/jres/icons/ultrasonicSensor-icon.png and b/libs/core/jres/icons/ultrasonicSensor-icon.png differ diff --git a/libs/core/output.ts b/libs/core/output.ts index 209e14d4..18fdf21e 100644 --- a/libs/core/output.ts +++ b/libs/core/output.ts @@ -87,21 +87,21 @@ namespace motors { } /** - * Sets the motor power level from ``-100`` to ``100``. + * Sets the motor speed level from ``-100`` to ``100``. * @param motor the output connection that the motor is connected to - * @param power the power from ``100`` full forward to ``-100`` full backward, eg: 50 + * @param speed the power from ``100`` full forward to ``-100`` full backward, eg: 50 */ - //% blockId=motorSetPower block="power `icons.motorLarge` %motor|to %power|%" + //% blockId=motorSetSpeed block="set speed `icons.motorLarge` %motor|to %speed|%" //% weight=99 group="Motors" blockGap=8 //% power.min=-100 power.max=100 - power(power: number) { - power = Math.clamp(-100, 100, power >> 0); + setSpeed(speed: number) { + speed = Math.clamp(-100, 100, speed >> 0); // per LEGO: call it power, use speed const b = mkCmd(this.port, DAL.opOutputSpeed, 1) - b.setNumber(NumberFormat.Int8LE, 2, power) + b.setNumber(NumberFormat.Int8LE, 2, speed) writePWM(b) - if (power) { + if (speed) { const b = mkCmd(this.port, DAL.opOutputStart, 0) writePWM(b); } else { @@ -141,7 +141,7 @@ namespace motors { const b = mkCmd(this.port, DAL.opOutputStop, 1) b.setNumber(NumberFormat.UInt8LE, 2, this.brake ? 1 : 0) writePWM(b); - } + } /** * Sets the automatic brake on or off when the motor is off diff --git a/libs/core/screen.ts b/libs/core/screen.ts index 4b95db85..d0582d92 100644 --- a/libs/core/screen.ts +++ b/libs/core/screen.ts @@ -154,7 +154,7 @@ namespace brick { //% blockId=scren_image_picker block="%image" shim=TD_ID //% image.fieldEditor="imagedropdown" //% image.fieldOptions.columns=6 - //% block.fieldOptions.hasSearchBar=true + //% image.fieldOptions.hasSearchBar=true //% group="Screen" weight=0 blockHidden=1 export function _imagePicker(image: Image): Image { return image; diff --git a/libs/ev3/pxt.json b/libs/ev3/pxt.json index a5c384c2..61752d25 100644 --- a/libs/ev3/pxt.json +++ b/libs/ev3/pxt.json @@ -12,7 +12,6 @@ "color-sensor": "file:../color-sensor", "touch-sensor": "file:../touch-sensor", "ultrasonic-sensor": "file:../ultrasonic-sensor", - "infrared-sensor": "file:../infrared-sensor", "gyro-sensor": "file:../gyro-sensor" }, "public": true diff --git a/libs/gyro-sensor/gyro.ts b/libs/gyro-sensor/gyro.ts index 59ed387f..98fd5159 100644 --- a/libs/gyro-sensor/gyro.ts +++ b/libs/gyro-sensor/gyro.ts @@ -27,6 +27,8 @@ namespace sensors { //% block="`icons.gyroSensor` %sensor|angle" //% blockId=gyroGetAngle //% parts="gyroscope" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=65 blockGap=8 //% group="Gyro Sensor" @@ -43,6 +45,8 @@ namespace sensors { //% block="`icons.gyroSensor` %sensor|rotation rate" //% blockId=gyroGetRate //% parts="gyroscope" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=65 blockGap=8 //% group="Gyro Sensor" @@ -51,16 +55,16 @@ namespace sensors { return this.getNumber(NumberFormat.Int16LE, 0) } } - - //% fixedInstance whenUsed block="1" + + //% fixedInstance whenUsed block="1" jres=icons.port1 export const gyro1: GyroSensor = new GyroSensor(1) - //% fixedInstance whenUsed block="2" weight=95 + //% fixedInstance whenUsed block="2" weight=95 jres=icons.port2 export const gyro2: GyroSensor = new GyroSensor(2) - - //% fixedInstance whenUsed block="3" + + //% fixedInstance whenUsed block="3" jres=icons.port3 export const gyro3: GyroSensor = new GyroSensor(3) - //% fixedInstance whenUsed block="4" + //% fixedInstance whenUsed block="4" jres=icons.port4 export const gyro4: GyroSensor = new GyroSensor(4) } diff --git a/libs/infrared-sensor/_locales/infrared-sensor-strings.json b/libs/infrared-sensor/_locales/infrared-sensor-strings.json index ac335a2d..e194d8dc 100644 --- a/libs/infrared-sensor/_locales/infrared-sensor-strings.json +++ b/libs/infrared-sensor/_locales/infrared-sensor-strings.json @@ -2,8 +2,8 @@ "InfraredSensorEvent.ObjectDetected|block": "object detected", "InfraredSensorEvent.ObjectNear|block": "object near", "sensors.InfraredSensor.onEvent|block": "on `icons.infraredSensor` %sensor|%event", - "sensors.InfraredSensor.proximity|block": "`icons.infraredSensor` %infrared|proximity", - "sensors.InfraredSensor.remoteCommand|block": "`icons.infraredSensor` %infrared|remote command", + "sensors.InfraredSensor.proximity|block": "`icons.infraredSensor` %sensor|proximity", + "sensors.InfraredSensor.remoteCommand|block": "`icons.infraredSensor` %sensor|remote command", "sensors.InfraredSensor.waitUntil|block": "wait until `icons.infraredSensor` %sensor| %event", "sensors.RemoteInfraredBeaconButton.isPressed|block": "`icons.infraredSensor` %button|is pressed", "sensors.RemoteInfraredBeaconButton.onEvent|block": "on `icons.infraredSensor` %button|%event", diff --git a/libs/infrared-sensor/ir.ts b/libs/infrared-sensor/ir.ts index c2788be4..a125e9fc 100644 --- a/libs/infrared-sensor/ir.ts +++ b/libs/infrared-sensor/ir.ts @@ -192,6 +192,8 @@ namespace sensors { //% block="on `icons.infraredSensor` %sensor|%event" //% blockId=infraredOn //% parts="infraredsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=100 blockGap=8 //% group="Infrared Sensor" @@ -206,6 +208,8 @@ namespace sensors { //% block="wait until `icons.infraredSensor` %sensor| %event" //% blockId=infraredwait //% parts="infraredsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=99 blockGap=8 //% group="Infrared Sensor" @@ -215,12 +219,14 @@ namespace sensors { /** * Get the promixity measured by the infrared sensor, from ``0`` (close) to ``100`` (far) - * @param ir the infrared sensor + * @param sensor the infrared sensor */ //% help=input/infrared/proximity - //% block="`icons.infraredSensor` %infrared|proximity" + //% block="`icons.infraredSensor` %sensor|proximity" //% blockId=infraredGetProximity //% parts="infrared" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=65 blockGap=8 //% group="Infrared Sensor" @@ -231,12 +237,14 @@ namespace sensors { /** * Get the remote commandreceived the infrared sensor. - * @param ir the infrared sensor + * @param sensor the infrared sensor */ //% help=input/infrared/remote-command - //% block="`icons.infraredSensor` %infrared|remote command" + //% block="`icons.infraredSensor` %sensor|remote command" //% blockId=infraredGetRemoteCommand //% parts="infrared" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=65 blockGap=8 //% group="Infrared Sensor" @@ -252,16 +260,16 @@ namespace sensors { } } - //% fixedInstance whenUsed block="1" + //% fixedInstance whenUsed block="1" jres=icons.port1 export const infraredSensor1: InfraredSensor = new InfraredSensor(1) - //% fixedInstance whenUsed block="2" + //% fixedInstance whenUsed block="2" jres=icons.port2 export const infraredSensor2: InfraredSensor = new InfraredSensor(2) - //% fixedInstance whenUsed block="3" + //% fixedInstance whenUsed block="3" jres=icons.port3 export const infraredSensor3: InfraredSensor = new InfraredSensor(3) - //% fixedInstance whenUsed block="4" + //% fixedInstance whenUsed block="4" jres=icons.port4 export const infraredSensor4: InfraredSensor = new InfraredSensor(4) diff --git a/libs/music/_locales/music-jsdoc-strings.json b/libs/music/_locales/music-jsdoc-strings.json index 3a616a81..2d67cdcf 100644 --- a/libs/music/_locales/music-jsdoc-strings.json +++ b/libs/music/_locales/music-jsdoc-strings.json @@ -11,10 +11,10 @@ "music.fromWAV": "Makes a sound bound to a buffer in WAV format.", "music.noteFrequency": "Get the frequency of a note.", "music.noteFrequency|param|name": "the note name, eg: Note.C", - "music.playSound": "Start playing a sound and don't wait for it to finish.", - "music.playSoundUntilDone": "Plays a sound", - "music.playSoundUntilDone|param|sound": "the sound to play", - "music.playSound|param|sound": "the sound to play", + "music.playSoundEffect": "Start playing a sound and don't wait for it to finish.", + "music.playSoundEffectUntilDone": "Plays a sound", + "music.playSoundEffectUntilDone|param|sound": "the sound to play", + "music.playSoundEffect|param|sound": "the sound to play", "music.playTone": "Play a tone through the speaker for some amount of time.", "music.playTone|param|frequency": "pitch of the tone to play in Hertz (Hz)", "music.playTone|param|ms": "tone duration in milliseconds (ms)", diff --git a/libs/music/_locales/music-strings.json b/libs/music/_locales/music-strings.json index 52485175..a74eae44 100644 --- a/libs/music/_locales/music-strings.json +++ b/libs/music/_locales/music-strings.json @@ -24,8 +24,8 @@ "music.beat|block": "%fraction|beat", "music.changeTempoBy|block": "change tempo by %value|(bpm)", "music.noteFrequency|block": "%note", - "music.playSoundUntilDone|block": "play sound %sound|until done", - "music.playSound|block": "play sound %sound", + "music.playSoundEffectUntilDone|block": "play sound effect %sound|until done", + "music.playSoundEffect|block": "play sound effect %sound", "music.playTone|block": "play tone|at %note=device_note|for %duration=device_beat", "music.rest|block": "rest|for %duration=device_beat", "music.ringTone|block": "ring tone|at %note=device_note", diff --git a/libs/music/sounds.ts b/libs/music/sounds.ts index fe5e6152..44c7cef0 100644 --- a/libs/music/sounds.ts +++ b/libs/music/sounds.ts @@ -256,13 +256,16 @@ namespace sounds { } namespace music { + let numSoundsPlaying = 0; + let soundsLimit = 3; + /** * Plays a sound * @param sound the sound to play */ - //% blockId=music_play_sound_until_done block="play sound %sound|until done" + //% blockId=music_play_sound_effect_until_done block="play sound effect %sound|until done" //% weight=98 - export function playSoundUntilDone(sound: Sound) { + export function playSoundEffectUntilDone(sound: Sound) { if (!sound) return; sound.play(); } @@ -281,9 +284,11 @@ namespace music { * Start playing a sound and don't wait for it to finish. * @param sound the sound to play */ - //% blockId=music_play_sound block="play sound %sound" + //% blockId=music_play_sound_effect block="play sound effect %sound" //% weight=99 - export function playSound(sound: Sound) { - control.runInBackground(() => sound.play()); + export function playSoundEffect(sound: Sound) { + if (!sound || numSoundsPlaying >= soundsLimit) return; + numSoundsPlaying++; + control.runInBackground(() => {sound.play(); numSoundsPlaying--;}); } } diff --git a/libs/touch-sensor/touch.ts b/libs/touch-sensor/touch.ts index 645d69ba..8484b83e 100644 --- a/libs/touch-sensor/touch.ts +++ b/libs/touch-sensor/touch.ts @@ -44,6 +44,8 @@ namespace sensors { //% help=input/touch-sensor/on-event //% blockId=touchEvent block="on `icons.touchSensor` %sensor|%event" //% parts="touch" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=99 blockGap=8 //% group="Touch Sensor" @@ -59,6 +61,8 @@ namespace sensors { //% help=input/touch-sensor/wait-until //% blockId=touchWaitUntil block="wait until `icons.touchSensor` %sensor|%event" //% parts="touch" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=98 blockGap=8 //% group="Touch Sensor" @@ -74,6 +78,8 @@ namespace sensors { //% block="`icons.touchSensor` %sensor|is pressed" //% blockId=touchIsPressed //% parts="touch" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=81 blockGap=8 //% group="Touch Sensor" @@ -89,6 +95,8 @@ namespace sensors { //% block="`icons.touchSensor` %sensor|was pressed" //% blockId=touchWasPressed //% parts="touch" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=81 blockGap=8 //% group="Touch Sensor" @@ -97,12 +105,12 @@ namespace sensors { } } - //% whenUsed block="1" weight=95 fixedInstance + //% whenUsed block="1" weight=95 fixedInstance jres=icons.port1 export const touchSensor1: TouchSensor = new TouchSensor(1) - //% whenUsed block="2" weight=95 fixedInstance + //% whenUsed block="2" weight=95 fixedInstance jres=icons.port2 export const touchSensor2: TouchSensor = new TouchSensor(2) - //% whenUsed block="3" weight=95 fixedInstance + //% whenUsed block="3" weight=95 fixedInstance jres=icons.port3 export const touchSensor3: TouchSensor = new TouchSensor(3) - //% whenUsed block="4" weight=95 fixedInstance + //% whenUsed block="4" weight=95 fixedInstance jres=icons.port4 export const touchSensor4: TouchSensor = new TouchSensor(4) } diff --git a/libs/ultrasonic-sensor/ultrasonic.ts b/libs/ultrasonic-sensor/ultrasonic.ts index ef6628af..f61f856f 100644 --- a/libs/ultrasonic-sensor/ultrasonic.ts +++ b/libs/ultrasonic-sensor/ultrasonic.ts @@ -45,6 +45,8 @@ namespace sensors { //% blockId=ultrasonicOn //% block="on `icons.ultrasonicSensor` %sensor|%event" //% parts="ultrasonicsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=100 blockGap=8 //% group="Ultrasonic Sensor" @@ -59,6 +61,8 @@ namespace sensors { //% block="wait until `icons.ultrasonicSensor` %sensor| %event" //% blockId=ultrasonicWait //% parts="ultrasonicsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=99 blockGap=8 //% group="Ultrasonic Sensor" @@ -74,6 +78,8 @@ namespace sensors { //% block="`icons.ultrasonicSensor` %sensor|distance" //% blockId=sonarGetDistance //% parts="ultrasonicsensor" + //% sensor.fieldEditor="imagedropdown" + //% sensor.fieldOptions.columns=4 //% blockNamespace=sensors //% weight=65 blockGap=8 //% group="Ultrasonic Sensor" @@ -84,15 +90,15 @@ namespace sensors { } } - //% fixedInstance whenUsed block="1" + //% fixedInstance whenUsed block="1" jres=icons.port1 export const ultrasonic1: UltraSonicSensor = new UltraSonicSensor(1) - //% fixedInstance whenUsed block="4" + //% fixedInstance whenUsed block="4" jres=icons.port4 export const ultrasonic4: UltraSonicSensor = new UltraSonicSensor(4) - //% fixedInstance whenUsed block="2" + //% fixedInstance whenUsed block="2" jres=icons.port2 export const ultrasonic2: UltraSonicSensor = new UltraSonicSensor(2) - //% fixedInstance whenUsed block="3" + //% fixedInstance whenUsed block="3" jres=icons.port3 export const ultrasonic3: UltraSonicSensor = new UltraSonicSensor(3) } diff --git a/package.json b/package.json index b1bf0b04..2d21827e 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "pxt-ev3", - "version": "0.0.35", + "version": "0.0.37", "description": "LEGO Mindstorms EV3 for Microsoft MakeCode", "private": true, "keywords": [ @@ -40,7 +40,7 @@ }, "dependencies": { "pxt-common-packages": "0.14.5", - "pxt-core": "2.3.31" + "pxt-core": "2.3.37" }, "scripts": { "test": "node node_modules/pxt-core/built/pxt.js travis" diff --git a/pxtarget.json b/pxtarget.json index 30dddfd8..31111b63 100644 --- a/pxtarget.json +++ b/pxtarget.json @@ -89,6 +89,8 @@ "termsOfUseUrl": "https://go.microsoft.com/fwlink/?LinkID=206977", "githubUrl": "https://github.com/Microsoft/pxt-ev3", "boardName": "LEGO Mindstorms EV3 Brick", + "selectLanguage": true, + "highContrast": true, "docMenu": [ { "name": "About",