pxt-calliope/libs/core/shims.d.ts

922 lines
35 KiB
TypeScript
Raw Normal View History

2016-04-02 02:45:18 +02:00
// Auto-generated. Do not edit.
2016-04-06 00:59:25 +02:00
/**
* Creation, manipulation and display of LED images.
*/
//% color=#7600A8 weight=31 icon="\uf03e"
//% advanced=true
2016-04-02 04:55:51 +02:00
declare namespace images {
/**
* Creates an image that fits on the LED screen.
*/
//% weight=75 help=images/create-image
//% blockId=device_build_image block="create image"
//% parts="ledmatrix" imageLiteral=1 shim=images::createImage
2016-04-02 04:55:51 +02:00
function createImage(leds: string): Image;
/**
* Creates an image with 2 frames.
*/
//% weight=74 help=images/create-big-image
//% blockId=device_build_big_image block="create big image" imageLiteral=2
//% parts="ledmatrix" shim=images::createBigImage
2016-04-02 04:55:51 +02:00
function createBigImage(leds: string): Image;
}
declare interface Image {
2016-04-13 02:10:37 +02:00
/**
* Plots the image at a given column to the screen
*/
//% help=images/plot-image
//% parts="ledmatrix" xOffset.defl=0 shim=ImageMethods::plotImage
plotImage(xOffset?: int32): void;
2016-04-13 02:10:37 +02:00
2016-04-02 04:55:51 +02:00
/**
* Shows an frame from the image at offset ``x offset``.
2016-05-27 05:42:15 +02:00
* @param xOffset column index to start displaying the image
2016-04-02 04:55:51 +02:00
*/
2016-05-27 05:42:15 +02:00
//% help=images/show-image weight=80 blockNamespace=images
//% blockId=device_show_image_offset block="show image %sprite(myImage)|at offset %offset" blockGap=8
//% parts="ledmatrix" async interval.defl=400 shim=ImageMethods::showImage
showImage(xOffset: int32, interval?: int32): void;
2016-04-02 04:55:51 +02:00
2016-04-13 02:10:37 +02:00
/**
* Draws the ``index``-th frame of the image on the screen.
2016-05-27 05:42:15 +02:00
* @param xOffset column index to start displaying the image
2016-04-13 02:10:37 +02:00
*/
//% help=images/plot-frame weight=80
//% parts="ledmatrix" shim=ImageMethods::plotFrame
plotFrame(xOffset: int32): void;
2016-04-13 02:10:37 +02:00
2016-04-02 04:55:51 +02:00
/**
* Scrolls an image .
2016-11-17 03:16:49 +01:00
* @param frameOffset x offset moved on each animation step, eg: 1, 2, 5
2016-04-02 04:55:51 +02:00
* @param interval time between each animation step in milli seconds, eg: 200
*/
2016-11-28 20:38:37 +01:00
//% help=images/scroll-image weight=79 async blockNamespace=images
//% blockId=device_scroll_image
//% block="scroll image %sprite(myImage)|with offset %frameoffset|and interval (ms) %delay"
//% blockGap=8 parts="ledmatrix" shim=ImageMethods::scrollImage
scrollImage(frameOffset: int32, interval: int32): void;
2016-04-02 04:55:51 +02:00
/**
* Sets all pixels off.
*/
//% help=images/clear
//% parts="ledmatrix" shim=ImageMethods::clear
2016-04-02 04:55:51 +02:00
clear(): void;
/**
* Sets a specific pixel brightness at a given position
*/
//%
//% parts="ledmatrix" shim=ImageMethods::setPixelBrightness
setPixelBrightness(x: int32, y: int32, value: int32): void;
2016-04-02 04:55:51 +02:00
/**
* Gets the pixel brightness ([0..255]) at a given position
*/
//%
//% parts="ledmatrix" shim=ImageMethods::pixelBrightness
pixelBrightness(x: int32, y: int32): int32;
2016-04-13 02:10:37 +02:00
/**
* Gets the width in columns
*/
//% help=functions/width shim=ImageMethods::width
width(): int32;
2016-04-13 02:10:37 +02:00
/**
* Gets the height in rows (always 5)
*/
2016-05-27 05:42:15 +02:00
//% shim=ImageMethods::height
height(): int32;
2016-04-13 02:10:37 +02:00
/**
* Set a pixel state at position ``(x,y)``
* @param x TODO
* @param y TODO
* @param value TODO
*/
//% help=images/set-pixel
//% parts="ledmatrix" shim=ImageMethods::setPixel
setPixel(x: int32, y: int32, value: boolean): void;
2016-04-13 02:10:37 +02:00
/**
* Get the pixel state at position ``(x,y)``
* @param x TODO
* @param y TODO
*/
//% help=images/pixel
//% parts="ledmatrix" shim=ImageMethods::pixel
pixel(x: int32, y: int32): boolean;
2016-04-13 02:10:37 +02:00
/**
* Shows a particular frame of the image strip.
* @param frame TODO
*/
//% weight=70 help=images/show-frame
//% parts="ledmatrix" interval.defl=400 shim=ImageMethods::showFrame
showFrame(frame: int32, interval?: int32): void;
2016-04-02 04:55:51 +02:00
}
2016-04-02 02:45:18 +02:00
/**
* Provides access to basic micro:bit functionality.
*/
//% color=#1E90FF weight=116 icon="\uf00a"
2016-04-02 02:45:18 +02:00
declare namespace basic {
/**
* Draws an image on the LED screen.
2016-06-14 15:30:07 +02:00
* @param leds the pattern of LED to turn on/off
* @param interval time in milliseconds to pause after drawing
2016-04-02 02:45:18 +02:00
*/
//% help=basic/show-leds
2016-04-02 02:45:18 +02:00
//% weight=95 blockGap=8
//% imageLiteral=1 async
2016-04-02 02:45:18 +02:00
//% blockId=device_show_leds
//% block="show leds" icon="\uf00a"
//% parts="ledmatrix" interval.defl=400 shim=basic::showLeds
function showLeds(leds: string, interval?: int32): void;
2016-04-02 02:45:18 +02:00
/**
* Display text on the display, one character at a time. If the string fits on the screen (i.e. is one letter), does not scroll.
* @param text the text to scroll on the screen, eg: "Hello!"
* @param interval how fast to shift characters; eg: 150, 100, 200, -100
*/
//% help=basic/show-string
//% weight=87 blockGap=16
//% block="show|string %text"
2016-04-02 02:45:18 +02:00
//% async
//% blockId=device_print_message
//% parts="ledmatrix"
//% text.shadowOptions.toString=true interval.defl=150 shim=basic::showString
function showString(text: string, interval?: int32): void;
2016-04-02 02:45:18 +02:00
/**
* Turn off all LEDs
*/
//% help=basic/clear-screen weight=79
//% blockId=device_clear_display block="clear screen"
2017-02-01 00:54:23 +01:00
//% parts="ledmatrix"
//% advanced=true shim=basic::clearScreen
2016-04-02 02:45:18 +02:00
function clearScreen(): void;
/**
* Shows a sequence of LED screens as an animation.
2016-06-14 15:30:07 +02:00
* @param leds pattern of LEDs to turn on/off
* @param interval time in milliseconds between each redraw
2016-04-02 02:45:18 +02:00
*/
//% help=basic/show-animation imageLiteral=1 async
//% parts="ledmatrix" interval.defl=400 shim=basic::showAnimation
function showAnimation(leds: string, interval?: int32): void;
2016-04-02 02:45:18 +02:00
/**
* Draws an image on the LED screen.
2016-06-14 15:30:07 +02:00
* @param leds pattern of LEDs to turn on/off
2016-04-02 02:45:18 +02:00
*/
//% help=basic/plot-leds weight=80
//% parts="ledmatrix" imageLiteral=1 shim=basic::plotLeds
2016-04-02 02:45:18 +02:00
function plotLeds(leds: string): void;
/**
* Repeats the code forever in the background. On each iteration, allows other codes to run.
2016-06-14 15:30:07 +02:00
* @param body code to execute
2016-04-02 02:45:18 +02:00
*/
//% help=basic/forever weight=55 blockGap=16 blockAllowMultiple=1 afterOnStart=true
2016-04-02 02:45:18 +02:00
//% blockId=device_forever block="forever" icon="\uf01e" shim=basic::forever
function forever(a: () => void): void;
/**
* Pause for the specified time in milliseconds
* @param ms how long to pause for, eg: 100, 200, 500, 1000, 2000
*/
//% help=basic/pause weight=54
//% async block="pause (ms) %pause" blockGap=16
//% blockId=device_pause icon="\uf110"
//% pause.shadow=timePicker shim=basic::pause
function pause(ms: int32): void;
2016-04-02 02:45:18 +02:00
}
//% color=#D400D4 weight=111 icon="\uf192"
2016-04-02 06:26:06 +02:00
declare namespace input {
/**
2017-07-28 19:05:53 +02:00
* Do something when a button (A, B or both A+B) is pushed down and released again.
2016-12-13 21:14:32 +01:00
* @param button the button that needs to be pressed
* @param body code to run when event is raised
2016-04-02 06:26:06 +02:00
*/
//% help=input/on-button-pressed weight=85 blockGap=16
//% blockId=device_button_event block="on button|%NAME|pressed"
//% parts="buttonpair" shim=input::onButtonPressed
2016-04-02 06:52:25 +02:00
function onButtonPressed(button: Button, body: () => void): void;
2016-04-02 06:26:06 +02:00
/**
* Do something when when a gesture is done (like shaking the micro:bit).
2016-12-13 21:14:32 +01:00
* @param gesture the type of gesture to track, eg: Gesture.Shake
* @param body code to run when gesture is raised
2016-04-02 06:26:06 +02:00
*/
//% help=input/on-gesture weight=84 blockGap=16
//% blockId=device_gesture_event block="on |%NAME"
//% parts="accelerometer"
//% NAME.fieldEditor="gestures" NAME.fieldOptions.columns=4 shim=input::onGesture
2016-04-02 06:52:25 +02:00
function onGesture(gesture: Gesture, body: () => void): void;
2016-04-02 06:26:06 +02:00
/**
2017-07-28 19:05:53 +02:00
* Do something when a pin is touched and released again (while also touching the GND pin).
2016-12-13 21:14:32 +01:00
* @param name the pin that needs to be pressed, eg: TouchPin.P0
2016-08-09 00:23:18 +02:00
* @param body the code to run when the pin is pressed
2016-04-02 06:26:06 +02:00
*/
//% help=input/on-pin-pressed weight=83 blockGap=32
//% blockId=device_pin_event block="on pin %name|pressed" shim=input::onPinPressed
2016-04-02 06:52:25 +02:00
function onPinPressed(name: TouchPin, body: () => void): void;
2016-04-02 06:26:06 +02:00
2016-08-09 00:23:18 +02:00
/**
* Do something when a pin is released.
2016-12-13 21:14:32 +01:00
* @param name the pin that needs to be released, eg: TouchPin.P0
2016-08-09 00:23:18 +02:00
* @param body the code to run when the pin is released
*/
//% help=input/on-pin-released weight=6 blockGap=16
//% blockId=device_pin_released block="on pin %NAME|released"
//% advanced=true shim=input::onPinReleased
2016-08-09 00:23:18 +02:00
function onPinReleased(name: TouchPin, body: () => void): void;
2016-04-02 06:26:06 +02:00
/**
* Get the button state (pressed or not) for ``A`` and ``B``.
2016-12-13 21:14:32 +01:00
* @param button the button to query the request, eg: Button.A
2016-04-02 06:26:06 +02:00
*/
//% help=input/button-is-pressed weight=60
2016-04-02 06:26:06 +02:00
//% block="button|%NAME|is pressed"
//% blockId=device_get_button2
//% icon="\uf192" blockGap=8
//% parts="buttonpair" shim=input::buttonIsPressed
2016-04-02 06:52:25 +02:00
function buttonIsPressed(button: Button): boolean;
2016-04-02 06:26:06 +02:00
2016-07-27 01:17:54 +02:00
/**
* Get the pin state (pressed or not). Requires to hold the ground to close the circuit.
2016-12-13 21:14:32 +01:00
* @param name pin used to detect the touch, eg: TouchPin.P0
2016-07-27 01:17:54 +02:00
*/
//% help=input/pin-is-pressed weight=58
//% blockId="device_pin_is_pressed" block="pin %NAME|is pressed"
//% blockGap=8 shim=input::pinIsPressed
2016-07-27 01:17:54 +02:00
function pinIsPressed(name: TouchPin): boolean;
/**
* Get the acceleration value in milli-gravitys (when the board is laying flat with the screen up, x=0, y=0 and z=-1024)
* @param dimension TODO
*/
//% help=input/acceleration weight=58
//% blockId=device_acceleration block="acceleration (mg)|%NAME" blockGap=8
//% parts="accelerometer" shim=input::acceleration
function acceleration(dimension: Dimension): int32;
/**
* Reads the light level applied to the LED screen in a range from ``0`` (dark) to ``255`` bright.
*/
//% help=input/light-level weight=57
//% blockId=device_get_light_level block="light level" blockGap=8
//% parts="ledmatrix" shim=input::lightLevel
function lightLevel(): int32;
2016-04-02 06:26:06 +02:00
/**
* Get the current compass heading in degrees.
2016-04-02 06:26:06 +02:00
*/
//% help=input/compass-heading
//% weight=56
//% blockId=device_heading block="compass heading (°)" blockGap=8
//% parts="compass" shim=input::compassHeading
function compassHeading(): int32;
2016-04-02 06:26:06 +02:00
/**
* Gets the temperature in Celsius degrees (°C).
*/
//% weight=55
2016-04-02 06:52:25 +02:00
//% help=input/temperature
//% blockId=device_temperature block="temperature (°C)" blockGap=8
//% parts="thermometer" shim=input::temperature
function temperature(): int32;
2016-04-02 06:26:06 +02:00
/**
* The pitch or roll of the device, rotation along the ``x-axis`` or ``y-axis``, in degrees.
2016-04-02 06:26:06 +02:00
* @param kind TODO
*/
2016-08-10 22:10:40 +02:00
//% help=input/rotation weight=52
//% blockId=device_get_rotation block="rotation (°)|%NAME" blockGap=8
//% parts="accelerometer" advanced=true shim=input::rotation
function rotation(kind: Rotation): int32;
2016-04-02 06:26:06 +02:00
/**
* Get the magnetic force value in ``micro-Teslas`` (``µT``). This function is not supported in the simulator.
* @param dimension TODO
*/
2016-04-02 06:52:25 +02:00
//% help=input/magnetic-force weight=51
//% blockId=device_get_magnetic_force block="magnetic force (µT)|%NAME" blockGap=8
//% parts="compass"
//% advanced=true shim=input::magneticForce
function magneticForce(dimension: Dimension): int32;
2016-04-02 06:26:06 +02:00
/**
* Gets the number of milliseconds elapsed since power on.
*/
//% help=input/running-time weight=50 blockGap=16
//% blockId=device_get_running_time block="running time (ms)"
//% advanced=true shim=input::runningTime
function runningTime(): int32;
2016-04-02 06:26:06 +02:00
/**
* Gets the number of microseconds elapsed since power on.
*/
//% help=input/running-time-micros weight=49
//% blockId=device_get_running_time_micros block="running time (micros)"
//% advanced=true shim=input::runningTimeMicros
function runningTimeMicros(): int32;
2016-04-02 06:26:06 +02:00
/**
* Obsolete, compass calibration is automatic.
*/
//% help=input/calibrate-compass advanced=true
//% blockId="input_compass_calibrate" block="calibrate compass" shim=input::calibrateCompass
function calibrateCompass(): void;
2016-04-02 06:26:06 +02:00
/**
* Sets the accelerometer sample range in gravities.
* @param range a value describe the maximum strengh of acceleration measured
*/
2016-07-21 22:46:22 +02:00
//% help=input/set-accelerometer-range
//% blockId=device_set_accelerometer_range block="set accelerometer|range %range"
//% weight=5
//% parts="accelerometer"
//% advanced=true shim=input::setAccelerometerRange
2016-04-02 06:52:25 +02:00
function setAccelerometerRange(range: AcceleratorRange): void;
2016-04-02 06:26:06 +02:00
}
2016-04-06 01:54:09 +02:00
2016-04-02 02:45:18 +02:00
//% weight=1 color="#333333"
//% advanced=true
2016-04-02 02:45:18 +02:00
declare namespace control {
/**
* Schedules code that run in the background.
*/
//% help=control/in-background blockAllowMultiple=1 afterOnStart=true
2016-04-02 02:45:18 +02:00
//% blockId="control_in_background" block="run in background" blockGap=8 shim=control::inBackground
function inBackground(a: () => void): void;
/**
* Resets the BBC micro:bit.
*/
2016-08-17 02:04:21 +02:00
//% weight=30 async help=control/reset blockGap=8
2016-04-02 02:45:18 +02:00
//% blockId="control_reset" block="reset" shim=control::reset
function reset(): void;
2016-08-17 02:04:21 +02:00
/**
* Blocks the current fiber for the given microseconds
* @param micros number of micro-seconds to wait. eg: 4
*/
//% help=control/wait-micros weight=29
//% blockId="control_wait_us" block="wait (µs)%micros" shim=control::waitMicros
function waitMicros(micros: int32): void;
2016-08-17 02:04:21 +02:00
2016-04-02 02:45:18 +02:00
/**
* Raises an event in the event bus.
* @param src ID of the MicroBit Component that generated the event e.g. MICROBIT_ID_BUTTON_A.
* @param value Component specific code indicating the cause of the event.
2016-04-14 23:29:28 +02:00
* @param mode optional definition of how the event should be processed after construction (default is CREATE_AND_FIRE).
2016-04-02 02:45:18 +02:00
*/
2016-05-17 01:24:44 +02:00
//% weight=21 blockGap=12 blockId="control_raise_event" block="raise event|from source %src=control_event_source_id|with value %value=control_event_value_id" blockExternalInputs=1
2017-07-24 22:51:17 +02:00
//% help=control/raise-event
2016-04-15 02:58:10 +02:00
//% mode.defl=1 shim=control::raiseEvent
function raiseEvent(src: int32, value: int32, mode?: EventCreationMode): void;
2016-04-02 02:45:18 +02:00
/**
* Registers an event handler.
2016-04-02 02:45:18 +02:00
*/
//% weight=20 blockGap=8 blockId="control_on_event" block="on event|from %src=control_event_source_id|with value %value=control_event_value_id"
2017-07-24 22:51:17 +02:00
//% help=control/on-event
2016-04-18 22:31:05 +02:00
//% blockExternalInputs=1 shim=control::onEvent
function onEvent(src: int32, value: int32, handler: () => void): void;
2016-04-26 22:43:02 +02:00
2016-05-17 01:24:44 +02:00
/**
* Gets the value of the last event executed on the bus
*/
//% blockId=control_event_value" block="event value"
2017-07-24 22:51:17 +02:00
//% help=control/event-value
2016-05-17 01:24:44 +02:00
//% weight=18 shim=control::eventValue
function eventValue(): int32;
2016-05-17 01:24:44 +02:00
/**
* Gets the timestamp of the last event executed on the bus
*/
//% blockId=control_event_timestamp" block="event timestamp"
2017-07-24 22:51:17 +02:00
//% help=control/event-timestamp
2016-05-17 18:36:01 +02:00
//% weight=19 blockGap=8 shim=control::eventTimestamp
function eventTimestamp(): int32;
2016-05-17 01:24:44 +02:00
2016-04-26 22:43:02 +02:00
/**
2018-05-09 19:58:01 +02:00
* Make a friendly name for the device based on its serial number
2016-04-26 22:43:02 +02:00
*/
//% blockId="control_device_name" block="device name" weight=10 blockGap=8
//% advanced=true shim=control::deviceName
2016-04-26 22:43:02 +02:00
function deviceName(): string;
2016-04-27 02:09:27 +02:00
/**
* Derive a unique, consistent serial number of this device from internal data.
*/
//% blockId="control_device_serial_number" block="device serial number" weight=9
//% advanced=true shim=control::deviceSerialNumber
function deviceSerialNumber(): int32;
/**
* Informs simulator/runtime of a MIDI message
* Internal function to support the simulator.
*/
//% part=midioutput block shim=control::__midiSend
function __midiSend(buffer: Buffer): void;
2016-04-02 02:45:18 +02:00
}
2016-04-02 06:26:06 +02:00
//% color=#7600A8 weight=101 icon="\uf205"
2016-04-02 06:52:25 +02:00
declare namespace led {
/**
* Turn on the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
* @param x the horizontal coordinate of the LED starting at 0
* @param y the vertical coordinate of the LED starting at 0
2016-04-02 06:52:25 +02:00
*/
2016-04-02 06:53:50 +02:00
//% help=led/plot weight=78
//% blockId=device_plot block="plot|x %x|y %y" blockGap=8
//% parts="ledmatrix"
//% x.min=0 x.max=4 y.min=0 y.max=4 shim=led::plot
function plot(x: int32, y: int32): void;
2016-04-02 06:52:25 +02:00
/**
* Turn on the specified LED with specific brightness using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
* @param x the horizontal coordinate of the LED starting at 0
* @param y the vertical coordinate of the LED starting at 0
* @param brightness the brightness from 0 (off) to 255 (bright), eg:255
*/
2017-08-18 17:15:43 +02:00
//% help=led/plot-brightness weight=78
2017-08-07 20:54:24 +02:00
//% blockId=device_plot_brightness block="plot|x %x|y %y|brightness %brightness" blockGap=8
//% parts="ledmatrix"
//% x.min=0 x.max=4 y.min=0 y.max=4 brightness.min=0 brightness.max=255
//% advanced=true shim=led::plotBrightness
function plotBrightness(x: int32, y: int32, brightness: int32): void;
2016-04-02 06:52:25 +02:00
/**
* Turn off the specified LED using x, y coordinates (x is horizontal, y is vertical). (0,0) is upper left.
* @param x TODO
* @param y TODO
*/
2016-04-02 06:53:50 +02:00
//% help=led/unplot weight=77
//% blockId=device_unplot block="unplot|x %x|y %y" blockGap=8
//% parts="ledmatrix"
//% x.min=0 x.max=4 y.min=0 y.max=4 shim=led::unplot
function unplot(x: int32, y: int32): void;
2016-04-02 06:52:25 +02:00
/**
* Get the on/off state of the specified LED using x, y coordinates. (0,0) is upper left.
* @param x TODO
* @param y TODO
*/
2016-04-02 06:53:50 +02:00
//% help=led/point weight=76
//% blockId=device_point block="point|x %x|y %y"
//% parts="ledmatrix"
//% x.min=0 x.max=4 y.min=0 y.max=4 shim=led::point
function point(x: int32, y: int32): boolean;
2016-04-02 06:52:25 +02:00
/**
* Get the screen brightness from 0 (off) to 255 (full bright).
*/
2016-04-02 06:53:50 +02:00
//% help=led/brightness weight=60
//% blockId=device_get_brightness block="brightness" blockGap=8
//% parts="ledmatrix"
//% advanced=true shim=led::brightness
function brightness(): int32;
2016-04-02 06:52:25 +02:00
/**
* Set the screen brightness from 0 (off) to 255 (full bright).
* @param value the brightness value, eg:255, 127, 0
*/
2016-04-02 06:53:50 +02:00
//% help=led/set-brightness weight=59
//% blockId=device_set_brightness block="set brightness %value"
//% parts="ledmatrix"
//% advanced=true
//% value.min=0 value.max=255 shim=led::setBrightness
function setBrightness(value: int32): void;
2016-04-02 06:52:25 +02:00
/**
* Cancels the current animation and clears other pending animations.
*/
2016-04-02 06:53:50 +02:00
//% weight=50 help=led/stop-animation
//% blockId=device_stop_animation block="stop animation"
//% parts="ledmatrix"
//% advanced=true shim=led::stopAnimation
2016-04-02 06:52:25 +02:00
function stopAnimation(): void;
/**
* Sets the display mode between black and white and greyscale for rendering LEDs.
* @param mode mode the display mode in which the screen operates
2016-04-02 06:52:25 +02:00
*/
//% weight=1 help=led/set-display-mode
//% parts="ledmatrix" advanced=true shim=led::setDisplayMode
2016-04-02 06:52:25 +02:00
function setDisplayMode(mode: DisplayMode): void;
/**
* Gets the current display mode
*/
//% weight=1 parts="ledmatrix" advanced=true shim=led::displayMode
function displayMode(): DisplayMode;
/**
2017-02-28 00:26:45 +01:00
* Turns on or off the display
*/
//% help=led/enable blockId=device_led_enable block="led enable %on"
//% advanced=true parts="ledmatrix" shim=led::enable
function enable(on: boolean): void;
2016-04-02 06:52:25 +02:00
/**
* Takes a screenshot of the LED screen and returns an image.
*/
//% help=led/screenshot
//% parts="ledmatrix" shim=led::screenshot
2016-04-02 06:52:25 +02:00
function screenshot(): Image;
}
2016-04-02 06:26:06 +02:00
declare namespace pins {
/**
* Read the specified pin or connector as either 0 or 1
2016-12-13 21:14:32 +01:00
* @param name pin to read from, eg: DigitalPin.P0
2016-04-02 06:26:06 +02:00
*/
2016-04-02 06:52:25 +02:00
//% help=pins/digital-read-pin weight=30
//% blockId=device_get_digital_pin block="digital read|pin %name" blockGap=8
//% name.fieldEditor="gridpicker" name.fieldOptions.columns=4
//% name.fieldOptions.tooltips="false" name.fieldOptions.width="300" shim=pins::digitalReadPin
function digitalReadPin(name: DigitalPin): int32;
2016-04-02 06:26:06 +02:00
/**
* Set a pin or connector value to either 0 or 1.
2016-12-13 21:14:32 +01:00
* @param name pin to write to, eg: DigitalPin.P0
2016-04-02 06:26:06 +02:00
* @param value value to set on the pin, 1 eg,0
*/
2016-04-02 06:52:25 +02:00
//% help=pins/digital-write-pin weight=29
//% blockId=device_set_digital_pin block="digital write|pin %name|to %value"
//% value.min=0 value.max=1
//% name.fieldEditor="gridpicker" name.fieldOptions.columns=4
//% name.fieldOptions.tooltips="false" name.fieldOptions.width="300" shim=pins::digitalWritePin
function digitalWritePin(name: DigitalPin, value: int32): void;
2016-04-02 06:26:06 +02:00
/**
* Read the connector value as analog, that is, as a value comprised between 0 and 1023.
2016-12-13 21:14:32 +01:00
* @param name pin to write to, eg: AnalogPin.P0
2016-04-02 06:26:06 +02:00
*/
2016-04-02 06:52:25 +02:00
//% help=pins/analog-read-pin weight=25
//% blockId=device_get_analog_pin block="analog read|pin %name" blockGap="8"
//% name.fieldEditor="gridpicker" name.fieldOptions.columns=4
//% name.fieldOptions.tooltips="false" shim=pins::analogReadPin
function analogReadPin(name: AnalogPin): int32;
2016-04-02 06:26:06 +02:00
/**
* Set the connector value as analog. Value must be comprised between 0 and 1023.
2016-12-13 21:14:32 +01:00
* @param name pin name to write to, eg: AnalogPin.P0
2016-04-02 06:26:06 +02:00
* @param value value to write to the pin between ``0`` and ``1023``. eg:1023,0
*/
2016-04-02 06:52:25 +02:00
//% help=pins/analog-write-pin weight=24
2017-03-04 08:42:36 +01:00
//% blockId=device_set_analog_pin block="analog write|pin %name|to %value" blockGap=8
//% value.min=0 value.max=1023
//% name.fieldEditor="gridpicker" name.fieldOptions.columns=4
//% name.fieldOptions.tooltips="false" shim=pins::analogWritePin
function analogWritePin(name: AnalogPin, value: int32): void;
2016-04-02 06:26:06 +02:00
/**
* Configures the Pulse-width modulation (PWM) of the analog output to the given value in **microseconds** or `1/1000` milliseconds.
* If this pin is not configured as an analog output (using `analog write pin`), the operation has no effect.
2016-12-13 21:14:32 +01:00
* @param name analog pin to set period to, eg: AnalogPin.P0
2016-04-02 06:26:06 +02:00
* @param micros period in micro seconds. eg:20000
*/
2016-05-25 06:39:57 +02:00
//% help=pins/analog-set-period weight=23 blockGap=8
//% blockId=device_set_analog_period block="analog set period|pin %pin|to (µs)%micros"
//% pin.fieldEditor="gridpicker" pin.fieldOptions.columns=4
//% pin.fieldOptions.tooltips="false" shim=pins::analogSetPeriod
function analogSetPeriod(name: AnalogPin, micros: int32): void;
2016-04-02 06:26:06 +02:00
2016-05-17 01:24:44 +02:00
/**
* Configures this pin to a digital input, and generates events where the timestamp is the duration that this pin was either ``high`` or ``low``.
2016-12-13 21:14:32 +01:00
* @param name digital pin to register to, eg: DigitalPin.P0
* @param pulse the value of the pulse, eg: PulseValue.High
2016-05-17 01:24:44 +02:00
*/
//% help=pins/on-pulsed weight=22 blockGap=16 advanced=true
//% blockId=pins_on_pulsed block="on|pin %pin|pulsed %pulse"
//% pin.fieldEditor="gridpicker" pin.fieldOptions.columns=4
//% pin.fieldOptions.tooltips="false" pin.fieldOptions.width="300" shim=pins::onPulsed
2016-05-17 01:24:44 +02:00
function onPulsed(name: DigitalPin, pulse: PulseValue, body: () => void): void;
/**
2016-05-25 06:39:57 +02:00
* Gets the duration of the last pulse in micro-seconds. This function should be called from a ``onPulsed`` handler.
2016-05-17 01:24:44 +02:00
*/
//% help=pins/pulse-duration advanced=true
2016-05-25 06:39:57 +02:00
//% blockId=pins_pulse_duration block="pulse duration (µs)"
2016-08-17 20:18:15 +02:00
//% weight=21 blockGap=8 shim=pins::pulseDuration
function pulseDuration(): int32;
2016-05-17 01:24:44 +02:00
2016-08-17 20:18:15 +02:00
/**
* Returns the duration of a pulse in microseconds
2016-12-13 21:14:32 +01:00
* @param name the pin which measures the pulse, eg: DigitalPin.P0
* @param value the value of the pulse, eg: PulseValue.High
2016-08-17 20:35:54 +02:00
* @param maximum duration in micro-seconds
2016-08-17 20:18:15 +02:00
*/
2016-08-17 20:35:54 +02:00
//% blockId="pins_pulse_in" block="pulse in (µs)|pin %name|pulsed %value"
//% weight=20 advanced=true
2017-07-24 22:51:17 +02:00
//% help=pins/pulse-in
//% name.fieldEditor="gridpicker" name.fieldOptions.columns=4
//% name.fieldOptions.tooltips="false" name.fieldOptions.width="300" maxDuration.defl=2000000 shim=pins::pulseIn
function pulseIn(name: DigitalPin, value: PulseValue, maxDuration?: int32): int32;
2016-08-17 20:18:15 +02:00
2016-04-02 06:26:06 +02:00
/**
* Writes a value to the servo, controlling the shaft accordingly. On a standard servo, this will set the angle of the shaft (in degrees), moving the shaft to that orientation. On a continuous rotation servo, this will set the speed of the servo (with ``0`` being full-speed in one direction, ``180`` being full speed in the other, and a value near ``90`` being no movement).
2016-12-13 21:14:32 +01:00
* @param name pin to write to, eg: AnalogPin.P0
2016-04-02 06:26:06 +02:00
* @param value angle or rotation speed, eg:180,90,0
*/
2016-04-02 06:52:25 +02:00
//% help=pins/servo-write-pin weight=20
2016-11-01 16:16:03 +01:00
//% blockId=device_set_servo_pin block="servo write|pin %name|to %value" blockGap=8
//% parts=microservo trackArgs=0
//% value.min=0 value.max=180
//% name.fieldEditor="gridpicker" name.fieldOptions.columns=4
//% name.fieldOptions.tooltips="false" shim=pins::servoWritePin
function servoWritePin(name: AnalogPin, value: int32): void;
2016-04-02 06:26:06 +02:00
/**
* Configures this IO pin as an analog/pwm output, configures the period to be 20 ms, and sets the pulse width, based on the value it is given **microseconds** or `1/1000` milliseconds.
* @param name pin name
* @param micros pulse duration in micro seconds, eg:1500
*/
2016-08-10 22:10:40 +02:00
//% help=pins/servo-set-pulse weight=19
//% blockId=device_set_servo_pulse block="servo set pulse|pin %value|to (µs) %micros"
//% value.fieldEditor="gridpicker" value.fieldOptions.columns=4
//% value.fieldOptions.tooltips="false" shim=pins::servoSetPulse
function servoSetPulse(name: AnalogPin, micros: int32): void;
2016-04-02 06:26:06 +02:00
/**
* Sets the pin used when using `analog pitch` or music.
* @param name pin to modulate pitch from
2016-04-02 06:26:06 +02:00
*/
//% blockId=device_analog_set_pitch_pin block="analog set pitch pin %name"
2017-07-24 22:51:17 +02:00
//% help=pins/analog-set-pitch-pin weight=3 advanced=true
//% name.fieldEditor="gridpicker" name.fieldOptions.columns=4
//% name.fieldOptions.tooltips="false" shim=pins::analogSetPitchPin
2016-04-02 06:52:25 +02:00
function analogSetPitchPin(name: AnalogPin): void;
2016-04-02 06:26:06 +02:00
/**
* Emits a Pulse-width modulation (PWM) signal to the current pitch pin. Use `analog set pitch pin` to define the pitch pin.
* @param frequency frequency to modulate in Hz.
* @param ms duration of the pitch in milli seconds.
2016-04-02 06:26:06 +02:00
*/
//% blockId=device_analog_pitch block="analog pitch %frequency|for (ms) %ms"
//% help=pins/analog-pitch weight=4 async advanced=true blockGap=8 shim=pins::analogPitch
function analogPitch(frequency: int32, ms: int32): void;
2016-04-04 01:52:57 +02:00
2016-06-04 08:15:51 +02:00
/**
* Configures the pull of this pin.
2016-12-13 21:14:32 +01:00
* @param name pin to set the pull mode on, eg: DigitalPin.P0
* @param pull one of the mbed pull configurations, eg: PinPullMode.PullUp
2016-06-04 08:15:51 +02:00
*/
//% help=pins/set-pull weight=3 advanced=true
//% blockId=device_set_pull block="set pull|pin %pin|to %pull"
//% pin.fieldEditor="gridpicker" pin.fieldOptions.columns=4
//% pin.fieldOptions.tooltips="false" pin.fieldOptions.width="300" shim=pins::setPull
2016-06-04 08:15:51 +02:00
function setPull(name: DigitalPin, pull: PinPullMode): void;
2017-01-30 20:19:54 +01:00
/**
* Configures the events emitted by this pin. Events can be subscribed to
* using ``control.onEvent()``.
* @param name pin to set the event mode on, eg: DigitalPin.P0
* @param type the type of events for this pin to emit, eg: PinEventType.Edge
*/
//% help=pins/set-events weight=4 advanced=true
//% blockId=device_set_pin_events block="set pin %pin|to emit %type|events"
//% pin.fieldEditor="gridpicker" pin.fieldOptions.columns=4
//% pin.fieldOptions.tooltips="false" pin.fieldOptions.width="300" shim=pins::setEvents
2017-01-30 20:19:54 +01:00
function setEvents(name: DigitalPin, type: PinEventType): void;
2016-04-04 01:52:57 +02:00
/**
* Create a new zero-initialized buffer.
* @param size number of bytes in the buffer
*/
//% shim=pins::createBuffer
function createBuffer(size: int32): Buffer;
/**
* Read `size` bytes from a 7-bit I2C `address`.
*/
//% repeat.defl=0 shim=pins::i2cReadBuffer
function i2cReadBuffer(address: int32, size: int32, repeat?: boolean): Buffer;
/**
* Write bytes to a 7-bit I2C `address`.
*/
//% repeat.defl=0 shim=pins::i2cWriteBuffer
function i2cWriteBuffer(address: int32, buf: Buffer, repeat?: boolean): void;
2016-08-11 08:26:58 +02:00
/**
* Write to the SPI slave and return the response
* @param value Data to be sent to the SPI slave
*/
//% help=pins/spi-write weight=5 advanced=true
2016-08-11 08:26:58 +02:00
//% blockId=spi_write block="spi write %value" shim=pins::spiWrite
function spiWrite(value: int32): int32;
2017-05-26 02:19:25 +02:00
/**
* Sets the SPI frequency
* @param frequency the clock frequency, eg: 1000000
*/
//% help=pins/spi-frequency weight=4 advanced=true
//% blockId=spi_frequency block="spi frequency %frequency" shim=pins::spiFrequency
function spiFrequency(frequency: int32): void;
2017-05-26 02:19:25 +02:00
/**
* Sets the SPI bits and mode
* @param bits the number of bits, eg: 8
* @param mode the mode, eg: 3
*/
//% help=pins/spi-format weight=3 advanced=true
//% blockId=spi_format block="spi format|bits %bits|mode %mode" shim=pins::spiFormat
function spiFormat(bits: int32, mode: int32): void;
2017-05-26 02:19:25 +02:00
/**
* Sets the MOSI, MISO, SCK pins used by the SPI instance
*
*/
//% help=pins/spi-pins weight=2 advanced=true
//% blockId=spi_pins block="spi set pins|MOSI %mosi|MISO %miso|SCK %sck"
//% mosi.fieldEditor="gridpicker" mosi.fieldOptions.columns=4
//% mosi.fieldOptions.tooltips="false" mosi.fieldOptions.width="300"
//% miso.fieldEditor="gridpicker" miso.fieldOptions.columns=4
//% miso.fieldOptions.tooltips="false" miso.fieldOptions.width="300"
//% sck.fieldEditor="gridpicker" sck.fieldOptions.columns=4
//% sck.fieldOptions.tooltips="false" sck.fieldOptions.width="300" shim=pins::spiPins
2017-05-26 02:19:25 +02:00
function spiPins(mosi: DigitalPin, miso: DigitalPin, sck: DigitalPin): void;
2016-04-02 06:26:06 +02:00
}
2016-04-02 07:00:42 +02:00
2017-02-28 00:26:45 +01:00
//% weight=2 color=#002050 icon="\uf287"
//% advanced=true
2016-04-02 07:00:42 +02:00
declare namespace serial {
/**
* Read a line of text from the serial port and return the buffer when the delimiter is met.
* @param delimiter text delimiter that separates each text chunk
*/
//% help=serial/read-until
//% blockId=serial_read_until block="serial|read until %delimiter=serial_delimiter_conv"
//% weight=19 shim=serial::readUntil
function readUntil(delimiter: string): string;
2016-04-02 07:00:42 +02:00
/**
* Read the buffered received data as a string
2016-04-02 07:00:42 +02:00
*/
2018-01-30 19:28:02 +01:00
//% help=serial/read-string
//% blockId=serial_read_buffer block="serial|read string"
//% weight=18 shim=serial::readString
function readString(): string;
/**
* Register an event to be fired when one of the delimiter is matched.
* @param delimiters the characters to match received characters against.
*/
//% help=serial/on-data-received
//% weight=18 blockId=serial_on_data_received block="serial|on data received %delimiters=serial_delimiter_conv" shim=serial::onDataReceived
function onDataReceived(delimiters: string, body: () => void): void;
2016-04-02 07:00:42 +02:00
/**
* Send a piece of text through the serial connection.
2016-04-02 07:00:42 +02:00
*/
2016-05-17 18:36:01 +02:00
//% help=serial/write-string
//% weight=87 blockGap=8
//% blockId=serial_writestring block="serial|write string %text"
//% text.shadowOptions.toString=true shim=serial::writeString
2016-04-02 07:00:42 +02:00
function writeString(text: string): void;
2016-05-26 20:07:09 +02:00
/**
* Send a buffer through serial connection
*/
//% blockId=serial_writebuffer block="serial|write buffer %buffer=serial_readbuffer"
//% help=serial/write-buffer advanced=true weight=6 shim=serial::writeBuffer
function writeBuffer(buffer: Buffer): void;
/**
* Read multiple characters from the receive buffer. Pause until enough characters are present.
* @param length default buffer length, eg: 64
*/
//% blockId=serial_readbuffer block="serial|read buffer %length"
//% help=serial/read-buffer advanced=true weight=5 shim=serial::readBuffer
function readBuffer(length: int32): Buffer;
2016-05-26 20:07:09 +02:00
/**
* Set the serial input and output to use pins instead of the USB connection.
* @param tx the new transmission pin, eg: SerialPin.P0
2016-12-13 21:14:32 +01:00
* @param rx the new reception pin, eg: SerialPin.P1
* @param rate the new baud rate. eg: 115200
2016-05-26 20:07:09 +02:00
*/
//% weight=10
//% help=serial/redirect
//% blockId=serial_redirect block="serial|redirect to|TX %tx|RX %rx|at baud rate %rate"
//% blockExternalInputs=1
//% tx.fieldEditor="gridpicker" tx.fieldOptions.columns=3
//% tx.fieldOptions.tooltips="false"
//% rx.fieldEditor="gridpicker" rx.fieldOptions.columns=3
//% rx.fieldOptions.tooltips="false"
//% blockGap=8 shim=serial::redirect
2016-05-26 20:07:09 +02:00
function redirect(tx: SerialPin, rx: SerialPin, rate: BaudRate): void;
/**
* Direct the serial input and output to use the USB connection.
*/
//% weight=9 help=serial/redirect-to-usb
//% blockId=serial_redirect_to_usb block="serial|redirect to USB" shim=serial::redirectToUSB
function redirectToUSB(): void;
2016-04-02 07:00:42 +02:00
}
2016-04-04 01:52:57 +02:00
//% indexerGet=BufferMethods::getByte indexerSet=BufferMethods::setByte
declare interface Buffer {
/**
* Write a number in specified format in the buffer.
*/
//% shim=BufferMethods::setNumber
setNumber(format: NumberFormat, offset: int32, value: number): void;
/**
* Read a number in specified format from the buffer.
*/
//% shim=BufferMethods::getNumber
getNumber(format: NumberFormat, offset: int32): number;
2016-04-04 01:52:57 +02:00
/** Returns the length of a Buffer object. */
//% property shim=BufferMethods::length
length: int32;
2016-04-04 01:52:57 +02:00
/**
* Fill (a fragment) of the buffer with given value.
*/
//% offset.defl=0 length.defl=-1 shim=BufferMethods::fill
fill(value: int32, offset?: int32, length?: int32): void;
2016-04-04 01:52:57 +02:00
/**
* Return a copy of a fragment of a buffer.
*/
//% offset.defl=0 length.defl=-1 shim=BufferMethods::slice
slice(offset?: int32, length?: int32): Buffer;
2016-04-04 01:52:57 +02:00
/**
* Shift buffer left in place, with zero padding.
* @param offset number of bytes to shift; use negative value to shift right
* @param start start offset in buffer. Default is 0.
* @param length number of elements in buffer. If negative, length is set as the buffer length minus
* start. eg: -1
2016-04-04 01:52:57 +02:00
*/
//% start.defl=0 length.defl=-1 shim=BufferMethods::shift
shift(offset: int32, start?: int32, length?: int32): void;
2016-04-04 01:52:57 +02:00
/**
* Convert a buffer to its hexadecimal representation.
*/
//% shim=BufferMethods::toHex
toHex(): string;
2016-04-04 01:52:57 +02:00
/**
* Rotate buffer left in place.
* @param offset number of bytes to shift; use negative value to shift right
* @param start start offset in buffer. Default is 0.
* @param length number of elements in buffer. If negative, length is set as the buffer length minus
* start. eg: -1
2016-04-04 01:52:57 +02:00
*/
//% start.defl=0 length.defl=-1 shim=BufferMethods::rotate
rotate(offset: int32, start?: int32, length?: int32): void;
2016-04-04 01:52:57 +02:00
/**
* Write contents of `src` at `dstOffset` in current buffer.
*/
//% shim=BufferMethods::write
write(dstOffset: int32, src: Buffer): void;
2016-04-04 01:52:57 +02:00
}
declare namespace control {
/**
* Create a new zero-initialized buffer.
* @param size number of bytes in the buffer
*/
//% shim=control::createBuffer
function createBuffer(size: int32): Buffer;
}
2016-04-04 01:52:57 +02:00
2016-04-02 02:45:18 +02:00
// Auto-generated. Do not edit. Really.