pxt-microbit
Version:
micro:bit target for Microsoft MakeCode (PXT)
1,205 lines (1,204 loc) • 44.4 kB
TypeScript
/// <reference path="../libs/core/dal.d.ts" />
/// <reference path="../libs/core/enums.d.ts" />
declare namespace pxsim {
interface CommonBoard extends CoreBoard, EventBusBoard {
bus: EventBus;
edgeConnectorState: EdgeConnectorState;
}
}
declare namespace pxsim {
class DalBoard extends CoreBoard implements CommonBoard, RadioBoard, LightBoard, MicrophoneBoard, ControlMessageBoard, samples.SampleBoard {
ledMatrixState: LedMatrixState;
edgeConnectorState: EdgeConnectorState;
serialState: SerialState;
accelerometerState: AccelerometerState;
compassState: CompassState;
thermometerState: ThermometerState;
lightSensorState: LightSensorState;
buttonPairState: ButtonPairState;
radioState: RadioState;
microphoneState: MicrophoneState;
recordingState: RecordingState;
lightState: pxt.Map<CommonNeoPixelState>;
fileSystem: FileSystemState;
logoTouch: Button;
speakerEnabled: boolean;
controlMessageState: ControlMessageState;
samplesState: samples.SamplesState;
viewHost: visuals.BoardHost;
view: SVGElement;
hardwareVersion: number;
constructor();
ensureHardwareVersion(version: number): void;
initAsync(msg: SimulatorRunMessage): Promise<void>;
tryGetNeopixelState(pinId: number): CommonNeoPixelState;
neopixelState(pinId: number): CommonNeoPixelState;
screenshotAsync(width?: number): Promise<ImageData>;
kill(): void;
}
function initRuntimeWithDalBoard(): void;
function board(): DalBoard;
function parsePinString(gpioPin: string): Pin;
}
declare namespace pxsim.input {
function onGesture(gesture: number, handler: RefAction): void;
function isGesture(gesture: number): boolean;
function acceleration(dimension: number): number;
function rotation(kind: number): number;
function setAccelerometerRange(range: number): void;
}
declare namespace pxsim {
/**
* Co-ordinate systems that can be used.
* RAW: Unaltered data. Data will be returned directly from the accelerometer.
*
* SIMPLE_CARTESIAN: Data will be returned based on an easy to understand alignment, consistent with the cartesian system taught in schools.
* When held upright, facing the user:
*
* /
* +--------------------+ z
* | |
* | ..... |
* | * ..... * |
* ^ | ..... |
* | | |
* y +--------------------+ x-->
*
*
* NORTH_EAST_DOWN: Data will be returned based on the industry convention of the North East Down (NED) system.
* When held upright, facing the user:
*
* z
* +--------------------+ /
* | |
* | ..... |
* | * ..... * |
* ^ | ..... |
* | | |
* x +--------------------+ y-->
*
*/
enum MicroBitCoordinateSystem {
RAW = 0,
SIMPLE_CARTESIAN = 1,
NORTH_EAST_DOWN = 2
}
enum AccelerometerFlag {
X = 1,
Y = 2,
Z = 4,
Strength = 8,
Pitch = 16,
Roll = 32
}
class Accelerometer {
runtime: Runtime;
private sigma;
private lastGesture;
private currentGesture;
private sample;
private shake;
private pitch;
private roll;
private id;
isActive: boolean;
sampleRange: number;
flags: AccelerometerFlag;
constructor(runtime: Runtime);
setSampleRange(range: number): void;
activate(flags?: AccelerometerFlag): void;
/**
* Reads the acceleration data from the accelerometer, and stores it in our buffer.
* This is called by the tick() member function, if the interrupt is set!
*/
update(x: number, y: number, z: number): void;
getStrength(): number;
updateEnvironmentGlobals(): void;
private instantaneousAccelerationSquared;
/**
* Service function. Determines the best guess posture of the device based on instantaneous data.
* This makes no use of historic data (except for shake), and forms this input to the filter implemented in updateGesture().
*
* @return A best guess of the current posture of the device, based on instantaneous data.
*/
private instantaneousPosture;
updateGesture(): void;
forceGesture(gesture: number): void;
private enqueueCurrentGesture;
/**
* Reads the X axis value of the latest update from the accelerometer.
* @param system The coordinate system to use. By default, a simple cartesian system is provided.
* @return The force measured in the X axis, in milli-g.
*
* Example:
* @code
* uBit.accelerometer.getX();
* uBit.accelerometer.getX(RAW);
* @endcode
*/
getX(system?: MicroBitCoordinateSystem): number;
/**
* Reads the Y axis value of the latest update from the accelerometer.
* @param system The coordinate system to use. By default, a simple cartesian system is provided.
* @return The force measured in the Y axis, in milli-g.
*
* Example:
* @code
* uBit.accelerometer.getY();
* uBit.accelerometer.getY(RAW);
* @endcode
*/
getY(system?: MicroBitCoordinateSystem): number;
/**
* Reads the Z axis value of the latest update from the accelerometer.
* @param system The coordinate system to use. By default, a simple cartesian system is provided.
* @return The force measured in the Z axis, in milli-g.
*
* Example:
* @code
* uBit.accelerometer.getZ();
* uBit.accelerometer.getZ(RAW);
* @endcode
*/
getZ(system?: MicroBitCoordinateSystem): number;
/**
* Provides a rotation compensated pitch of the device, based on the latest update from the accelerometer.
* @return The pitch of the device, in degrees.
*
* Example:
* @code
* uBit.accelerometer.getPitch();
* @endcode
*/
getPitch(): number;
getPitchRadians(): number;
/**
* Provides a rotation compensated roll of the device, based on the latest update from the accelerometer.
* @return The roll of the device, in degrees.
*
* Example:
* @code
* uBit.accelerometer.getRoll();
* @endcode
*/
getRoll(): number;
getRollRadians(): number;
getGesture(): number;
/**
* Recalculate roll and pitch values for the current sample.
* We only do this at most once per sample, as the necessary trigonemteric functions are rather
* heavyweight for a CPU without a floating point unit...
*/
recalculatePitchRoll(): void;
}
class AccelerometerState {
accelerometer: Accelerometer;
useShake: boolean;
constructor(runtime: Runtime);
shake(): void;
}
}
declare namespace pxsim.pxtcore {
function updateScreen(img: RefImage): void;
function updateStats(s: string): void;
function setPalette(b: RefBuffer): void;
function setScreenBrightness(b: number): void;
function displayHeight(): number;
function displayWidth(): number;
function displayPresent(): boolean;
}
declare namespace pxsim.samples {
export interface SampleBoard extends EventBusBoard {
samplesState: SamplesState;
}
class SampleChannel {
id: number;
sampleRate: number;
protected playing: AudioContextManager.PlaySampleResult;
constructor(id: number);
playSampleAsync(sample: RefBuffer): void;
}
export class SamplesState {
protected channels: SampleChannel[];
protected enabled: boolean;
constructor();
setEnabled(enabled: boolean): void;
setSampleRate(channelId: number, sampleRate: number): void;
playSampleAsync(channelId: number, sample: RefBuffer): void;
}
export function enable(): void;
export function disable(): void;
export function setSampleRate(src: number, sampleRate: number): void;
export function playAsync(src: number, buf: RefBuffer): void;
export {};
}
declare namespace pxsim {
class RefImage extends RefObject {
_width: number;
_height: number;
_bpp: number;
data: Uint8Array;
isStatic: boolean;
revision: number;
constructor(w: number, h: number, bpp: number);
scan(mark: (path: string, v: any) => void): void;
gcKey(): string;
gcSize(): number;
gcIsStatic(): boolean;
pix(x: number, y: number): number;
inRange(x: number, y: number): boolean;
color(c: number): number;
clamp(x: number, y: number): number[];
makeWritable(): void;
toDebugString(): string;
}
}
declare namespace pxsim.BitmapMethods {
function XX(x: number): number;
function YY(x: number): number;
function __buffer(img: RefImage): RefBuffer;
function width(img: RefImage): number;
function height(img: RefImage): number;
function isMono(img: RefImage): boolean;
function isStatic(img: RefImage): boolean;
function revision(img: RefImage): number;
function setPixel(img: RefImage, x: number, y: number, c: number): void;
function getPixel(img: RefImage, x: number, y: number): number;
function fill(img: RefImage, c: number): void;
function fillRect(img: RefImage, x: number, y: number, w: number, h: number, c: number): void;
function _fillRect(img: RefImage, xy: number, wh: number, c: number): void;
function mapRect(img: RefImage, x: number, y: number, w: number, h: number, c: RefBuffer): void;
function _mapRect(img: RefImage, xy: number, wh: number, c: RefBuffer): void;
function equals(img: RefImage, other: RefImage): boolean;
function getRows(img: RefImage, x: number, dst: RefBuffer): void;
function setRows(img: RefImage, x: number, src: RefBuffer): void;
function clone(img: RefImage): RefImage;
function flipX(img: RefImage): void;
function flipY(img: RefImage): void;
function transposed(img: RefImage): RefImage;
function copyFrom(img: RefImage, from: RefImage): void;
function scroll(img: RefImage, dx: number, dy: number): void;
function replace(img: RefImage, from: number, to: number): void;
function doubledX(img: RefImage): RefImage;
function doubledY(img: RefImage): RefImage;
function doubled(img: RefImage): RefImage;
function drawBitmap(img: RefImage, from: RefImage, x: number, y: number): void;
function drawTransparentBitmap(img: RefImage, from: RefImage, x: number, y: number): void;
function overlapsWith(img: RefImage, other: RefImage, x: number, y: number): boolean;
function _drawLine(img: RefImage, xy: number, wh: number, c: number): void;
function drawLine(img: RefImage, x0: number, y0: number, x1: number, y1: number, c: number): void;
function drawIcon(img: RefImage, icon: RefBuffer, x: number, y: number, color: number): void;
function _drawIcon(img: RefImage, icon: RefBuffer, xy: number, color: number): void;
function fillCircle(img: RefImage, cx: number, cy: number, r: number, c: number): void;
function _fillCircle(img: RefImage, cxy: number, r: number, c: number): void;
function fillTriangle(img: RefImage, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, c: number): void;
function _fillTriangle(img: RefImage, args: RefCollection): void;
function fillPolygon4(img: RefImage, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, c: number): void;
function _fillPolygon4(img: RefImage, args: RefCollection): void;
function _blitRow(img: RefImage, xy: number, from: RefImage, xh: number): void;
function blitRow(img: RefImage, x: number, y: number, from: RefImage, fromX: number, fromH: number): void;
function _blit(img: RefImage, src: RefImage, args: RefCollection): boolean;
function blit(dst: RefImage, src: RefImage, args: RefCollection): boolean;
}
declare namespace pxsim.bitmaps {
function byteHeight(h: number, bpp: number): number;
function bufW(data: Uint8Array): number;
function bufH(data: Uint8Array): number;
function isValidImage(buf: RefBuffer): boolean;
function create(w: number, h: number): RefImage;
function ofBuffer(buf: RefBuffer): RefImage;
function toBuffer(img: RefImage): RefBuffer;
function doubledIcon(buf: RefBuffer): RefBuffer;
}
declare namespace pxsim.input {
function onButtonPressed(button: number, handler: RefAction): void;
function buttonIsPressed(button: number): boolean;
}
declare namespace pxsim.visuals {
function mkBtnSvg(xy: Coord): SVGAndSize<SVGGElement>;
const BUTTON_PAIR_STYLE: string;
class ButtonPairView implements IBoardPart<ButtonPairState> {
element: SVGElement;
defs: SVGElement[];
style: string;
private state;
private bus;
private aBtn;
private bBtn;
private abBtn;
init(bus: EventBus, state: ButtonPairState): void;
moveToCoord(xy: Coord): void;
updateState(): void;
updateTheme(): void;
private mkBtns;
private attachEvents;
}
}
declare namespace pxsim.input {
function compassHeading(): number;
function magneticForce(): number;
}
declare namespace pxsim.input {
function onPinPressed(pinId: number, handler: RefAction): void;
function onPinReleased(pinId: number, handler: RefAction): void;
function pinIsPressed(pinId: number): boolean;
}
declare namespace pxsim {
function getPin(id: number): Pin;
}
declare namespace pxsim.pins {
let edgeConnectorSoundDisabled: boolean;
function digitalReadPin(pinId: number): number;
function digitalWritePin(pinId: number, value: number): void;
function setPull(pinId: number, pull: number): void;
function analogReadPin(pinId: number): number;
function analogWritePin(pinId: number, value: number): void;
function analogSetPeriod(pinId: number, micros: number): void;
function servoWritePin(pinId: number, value: number): void;
function servoSetContinuous(pinId: number, value: boolean): void;
function servoSetPulse(pinId: number, micros: number): void;
function analogSetPitchPin(pinId: number): void;
function setSoundOutputPinEnabled(enabled: boolean): void;
function analogSetPitchVolume(volume: number): void;
function analogPitchVolume(): number;
function analogPitch(frequency: number, ms: number): void;
function pushButton(pinId: number): void;
}
declare namespace pxsim.music {
function setVolume(volume: number): void;
function volume(): number;
}
declare namespace pxsim.pins {
function setAudioPin(pinId: number): void;
function setAudioPinEnabled(enabled: boolean): void;
}
declare namespace pxsim {
enum PinFlags {
Unused = 0,
Digital = 1,
Analog = 2,
Input = 4,
Output = 8,
Touch = 16
}
class Pin {
id: number;
constructor(id: number);
touched: boolean;
value: number;
period: number;
servoAngle: number;
mode: PinFlags;
pitch: boolean;
pull: number;
servoContinuous: boolean;
digitalReadPin(): number;
digitalWritePin(value: number): void;
setPull(pull: number): void;
analogReadPin(): number;
analogWritePin(value: number): void;
analogSetPeriod(micros: number): void;
servoWritePin(value: number): void;
servoSetContinuous(value: boolean): void;
servoSetPulse(pinId: number, micros: number): void;
isTouched(): boolean;
}
interface EdgeConnectorProps {
pins: number[];
servos?: {
[name: string]: number;
};
}
class EdgeConnectorState {
props: EdgeConnectorProps;
pins: Pin[];
pitchVolume: number;
pitchEnabled: boolean;
constructor(props: EdgeConnectorProps);
getPin(id: number): Pin;
}
}
declare namespace pxsim.files {
function appendLine(filename: string, text: string): void;
function appendString(filename: string, text: string): void;
function appendNumber(filename: string, value: number): void;
function remove(filename: string): void;
function readToSerial(filename: string): void;
}
declare namespace pxsim.flashlog {
enum FlashLogTimeStampFormat {
None = 0,
Milliseconds = 1,
Seconds = 10,
Minutes = 600,
Hours = 36000,
Days = 864000
}
export function beginRow(): number;
export function logData(key: string, value: string, prepend?: boolean): DAL.MUTEX | DAL.DEVICE_INVALID_STATE;
export function endRow(): number;
export function logString(s: string): void;
export function clear(fullErase: boolean): void;
export function setTimeStamp(format: FlashLogTimeStampFormat): void;
export function setSerialMirroring(enabled: boolean): void;
export function getNumberOfRows(fromRowIndex?: number): number;
export function getRows(fromRowIndex: number, nRows: number): string;
export {};
}
declare namespace pxsim {
enum DisplayMode {
bw = 0,
greyscale = 1
}
class LedMatrixState {
image: Image;
brigthness: number;
displayMode: DisplayMode;
font: Image;
disabled: boolean;
animationQ: AnimationQueue;
constructor(runtime: Runtime);
}
class Image extends RefObject {
height: number;
width: number;
data: number[];
constructor(width: number, data: number[]);
print(): void;
get(x: number, y: number): number;
set(x: number, y: number, v: number): void;
copyTo(xSrcIndex: number, length: number, target: Image, xTargetIndex: number): void;
shiftLeft(cols: number): void;
shiftRight(cols: number): void;
clear(): void;
}
function createInternalImage(width: number): Image;
function createImage(width: number): Image;
function createImageFromBuffer(data: number[]): Image;
function createImageFromString(text: string): Image;
const FONT_DATA: number[];
function createFont(): Image;
}
declare namespace pxsim.fonts {
function charCodeBuffer(charCode: number): RefBuffer;
}
declare namespace pxsim.images {
function createImage(img: Image): Image;
function createBigImage(img: Image): Image;
}
declare namespace pxsim.ImageMethods {
function showImage(leds: Image, offset: number, interval: number): void;
function plotImage(leds: Image, offset: number): void;
function height(leds: Image): number;
function width(leds: Image): number;
function plotFrame(leds: Image, frame: number): void;
function showFrame(leds: Image, frame: number, interval: number): void;
function pixel(leds: Image, x: number, y: number): number;
function setPixel(leds: Image, x: number, y: number, v: number): void;
function clear(leds: Image): void;
function setPixelBrightness(i: Image, x: number, y: number, b: number): void;
function pixelBrightness(i: Image, x: number, y: number): number;
function scrollImage(leds: Image, stride: number, interval: number): void;
}
declare namespace pxsim.basic {
function showNumber(x: number, interval: number): void;
function showString(s: string, interval: number): void;
function showLeds(leds: Image, interval: number): void;
function clearScreen(): void;
function showAnimation(leds: Image, interval: number): void;
function plotLeds(leds: Image): void;
}
declare namespace pxsim.led {
function plot(x: number, y: number): void;
function plotBrightness(x: number, y: number, brightness: number): void;
function unplot(x: number, y: number): void;
function pointBrightness(x: number, y: number): number;
function brightness(): number;
function setBrightness(value: number): void;
function stopAnimation(): void;
function setDisplayMode(mode: DisplayMode): void;
function displayMode(): DisplayMode;
function screenshot(): Image;
function enable(on: boolean): void;
}
declare namespace pxsim.input {
function lightLevel(): number;
}
declare namespace pxsim.input {
function onLogoEvent(action: number, handler: RefAction): void;
function logoIsPressed(): boolean;
}
declare namespace pxsim.pins {
function touchSetMode(name: number, mode: number): void;
}
declare namespace pxsim.input {
function soundLevel(): number;
function onSound(sound: number, body: RefAction): void;
function setSoundThreshold(sound: number, threshold: number): void;
}
declare namespace pxsim.visuals {
function mkMicroServoPart(xy?: Coord): SVGElAndSize;
class MicroServoView implements IBoardPart<EdgeConnectorState> {
style: string;
overElement: SVGElement;
element: SVGElement;
defs: SVGElement[];
state: EdgeConnectorState;
bus: EventBus;
private currentAngle;
private targetAngle;
private lastAngleTime;
private pin;
private crankEl;
private crankTransform;
init(bus: EventBus, state: EdgeConnectorState, svgEl: SVGSVGElement, otherParams: Map<string>): void;
initDom(): void;
moveToCoord(xy: visuals.Coord): void;
updateState(): void;
private renderAngle;
updateTheme(): void;
}
}
declare namespace pxsim.control {
function __midiSend(data: RefBuffer): void;
}
declare namespace pxsim {
/**
* Error codes used in the micro:bit runtime.
*/
enum PanicCode {
MICROBIT_OOM = 20,
MICROBIT_HEAP_ERROR = 30,
MICROBIT_NULL_DEREFERENCE = 40
}
function panic(code: number): void;
interface RuntimeOptions {
theme: string;
}
}
declare namespace pxsim.basic {
var pause: typeof thread.pause;
var forever: typeof thread.forever;
}
declare namespace pxsim.control {
var inBackground: typeof thread.runInBackground;
function onEvent(id: number, evid: number, handler: RefAction, flags: number): void;
function eventTimestamp(): number;
function eventValue(): string | number;
}
declare namespace pxsim.input {
function calibrateCompass(): void;
}
declare namespace pxsim.pins {
function onPulsed(name: number, pulse: number, body: RefAction): void;
function pulseDuration(): number;
function createBuffer(sz: number): RefBuffer;
function pulseIn(name: number, value: number, maxDuration: number): number;
function spiWrite(value: number): number;
function spiTransfer(cmd: RefBuffer, resp: RefBuffer): void;
function spiFrequency(f: number): void;
function spiFormat(bits: number, mode: number): void;
function spiPins(mosi: number, miso: number, sck: number): void;
function i2cReadBuffer(address: number, size: number, repeat?: boolean): RefBuffer;
function i2cWriteBuffer(address: number, buf: RefBuffer, repeat?: boolean): void;
function getPinAddress(name: number): Pin;
function setEvents(name: number, event: number): void;
function setMatrixWidth(pin: number, width: number): void;
}
declare namespace pxsim.devices {
function tellCameraTo(action: number): void;
function tellRemoteControlTo(action: number): void;
function raiseAlertTo(action: number): void;
function onSignalStrengthChanged(action: number): void;
function signalStrength(): number;
function onGamepadButton(button: number, body: RefAction): void;
}
declare namespace pxsim.bluetooth {
function startIOPinService(): void;
function startLEDService(): void;
function startTemperatureService(): void;
function startMagnetometerService(): void;
function startAccelerometerService(): void;
function startButtonService(): void;
function startUartService(): void;
function uartWriteString(s: string): void;
function uartWriteBuffer(b: RefBuffer): void;
function uartReadBuffer(): RefBuffer;
function uartReadUntil(del: string): string;
function onUartDataReceived(delimiters: string, handler: RefAction): void;
function onBluetoothConnected(a: RefAction): void;
function onBluetoothDisconnected(a: RefAction): void;
function advertiseUrl(url: string, power: number, connectable: boolean): void;
function advertiseUidBuffer(nsAndInstance: RefBuffer, power: number, connectable: boolean): void;
function stopAdvertising(): void;
function setTransmitPower(power: number): void;
}
declare namespace pxsim.light {
function sendWS2812Buffer(buffer: RefBuffer, pin: number): void;
function sendWS2812BufferWithBrightness(buffer: RefBuffer, pin: number, brightness: number): void;
function setMode(pin: number, mode: number): void;
}
declare namespace pxsim.music {
function setBuiltInSpeakerEnabled(enabled: boolean): void;
function setSilenceLevel(level: number): void;
function isSoundPlaying(): boolean;
}
declare namespace pxsim.music {
interface Progression {
interval: number[];
length: number;
}
}
declare namespace pxsim.music.MusicalIntervals {
const chromaticInterval: number[];
const majorScaleInterval: number[];
const minorScaleInterval: number[];
const pentatonicScaleInterval: number[];
const majorTriadInterval: number[];
const minorTriadInterval: number[];
const diminishedInterval: number[];
const wholeToneInterval: number[];
}
declare namespace pxsim.music.MusicalProgressions {
const chromatic: Progression;
const majorScale: Progression;
const minorScale: Progression;
const pentatonicScale: Progression;
const majorTriad: Progression;
const minorTriad: Progression;
const diminished: Progression;
const wholeTone: Progression;
/**
* Determine the frequency of a given note in a given progressions
*
* @param root The root frequency of the progression
* @param progression The Progression to use
* @param offset The offset (interval) of the note to generate
* @return The frequency of the note requested in Hz.
*/
function calculateFrequencyFromProgression(root: number, progression: Progression, offset: number): number;
}
declare namespace pxsim {
class RecordingState {
currentlyRecording: boolean;
stream: MediaStream;
recorder: MediaRecorder;
chunks: Blob[];
audioURL: string;
audioURLBitRate: number;
audioClippingThreshold: number;
recording: HTMLAudioElement;
audioPlaying: boolean;
recordTimeoutID: any;
currentlyErasing: boolean;
inputBitRate: number;
outputBitRate: number;
handleAudioPlaying: () => void;
handleAudioStopped: () => void;
initListeners: () => void;
}
}
declare namespace pxsim.record {
function record(): Promise<void>;
function play(): void;
function stop(): void;
function erase(): void;
function setMicrophoneGain(gain: number): void;
function audioDuration(sampleRate: number): number;
function audioIsPlaying(): boolean;
function audioIsRecording(): boolean;
function audioIsStopped(): boolean;
function setInputSampleRate(sampleRate: number): void;
function setOutputSampleRate(sampleRate: number): void;
function setBothSamples(sampleRate: number): void;
function defaultBitRate(): number;
}
declare namespace pxsim {
class SerialState {
private readonly runtime;
private readonly board;
serialIn: string[];
constructor(runtime: Runtime, board: BaseBoard);
private handleMessage;
receiveData(data: string): void;
readSerial(): string;
serialOutBuffer: string;
writeSerial(s: string): void;
writeCsv(s: string, type: "headers" | "row" | "clear"): void;
}
}
declare namespace pxsim.serial {
function writeString(s: string): void;
function writeBuffer(buf: RefBuffer): void;
function readUntil(del: string): string;
function readString(): string;
function onDataReceived(delimiters: string, handler: RefAction): void;
function redirect(tx: number, rx: number, rate: number): void;
function redirectToUSB(): void;
function setRxBufferSize(size: number): void;
function setTxBufferSize(size: number): void;
function readBuffer(length: number): RefBuffer;
function setBaudRate(rate: number): void;
function writeDmesg(): void;
}
declare namespace pxsim.music {
function __playSoundExpression(notes: string, waitTillDone: boolean): void;
function __stopSoundExpressions(): void;
}
declare namespace pxsim {
class ThermometerState {
usesTemperature: boolean;
temperature: number;
}
}
declare namespace pxsim.input {
function temperature(): number;
}
declare namespace pxsim.visuals {
}
declare namespace pxsim.visuals {
function mkLedMatrixSvg(xy: Coord, rows: number, cols: number): {
el: SVGGElement;
y: number;
x: number;
w: number;
h: number;
leds: SVGElement[];
ledsOuter: SVGElement[];
background: SVGElement;
};
interface ILedMatrixTheme {
background?: string;
ledOn?: string;
ledOff?: string;
}
var defaultLedMatrixTheme: ILedMatrixTheme;
const LED_MATRIX_STYLE = "\n .sim-led-back:hover {\n stroke:#a0a0a0;\n stroke-width:3px;\n }\n .sim-led:hover {\n stroke:#ff7f7f;\n stroke-width:3px;\n }\n ";
class LedMatrixView implements IBoardPart<LedMatrixState> {
private background;
private ledsOuter;
private leds;
private state;
private bus;
element: SVGElement;
defs: SVGElement[];
private theme;
private DRAW_SIZE;
private ACTIVE_SIZE;
style: string;
init(bus: EventBus, state: LedMatrixState): void;
moveToCoord(xy: Coord): void;
updateTheme(): void;
updateState(): void;
buildDom(): SVGGElement;
}
}
declare namespace pxsim.visuals {
interface IBoardTheme {
highContrast?: boolean;
accent?: string;
display?: string;
pin?: string;
pinTouched?: string;
pinActive?: string;
ledOn?: string;
ledOff?: string;
buttonOuter?: string;
buttonUp?: string;
buttonDown?: string;
virtualButtonOuter?: string;
virtualButtonUp?: string;
virtualButtonDown?: string;
lightLevelOn?: string;
lightLevelOff?: string;
}
var themes: IBoardTheme[];
function randomTheme(highContrast?: boolean): IBoardTheme;
interface IBoardProps {
runtime?: pxsim.Runtime;
theme?: IBoardTheme;
wireframe?: boolean;
}
class MicrobitBoardSvg implements BoardView {
props: IBoardProps;
element: SVGSVGElement;
private style;
private defs;
private g;
private pkg;
private logos;
private head;
private headParts;
private headInitialized;
private heads;
private headText;
private display;
private buttons;
private buttonsOuter;
private buttonABText;
private pins;
private pinGradients;
private pinTexts;
private ledsOuter;
private leds;
private microphoneLed;
private systemLed;
private antenna;
private antennaInitialized;
private rssi;
private lightLevelButton;
private lightLevelGradient;
private lightLevelInitialized;
private lightLevelText;
private thermometerGradient;
private thermometer;
private thermometerInitialized;
private thermometerText;
private soundLevelGradient;
private soundLevel;
private soundLevelInitialized;
private soundLevelText;
private shakeButton;
private shakeInitialized;
private shakeText;
private accTextX;
private accTextY;
private accTextZ;
private v2Circle;
private v2Text;
board: pxsim.DalBoard;
private pinNmToCoord;
private domHardwareVersion;
private moveHeadingOnClick;
constructor(props: IBoardProps);
getView(): SVGAndSize<SVGSVGElement>;
getCoord(pinNm: string): Coord;
highlightPin(pinNm: string): void;
getPinDist(): number;
recordPinCoords(): void;
removeEventListeners(): void;
private updateTheme;
updateState(): void;
private updateButtonPairs;
private updateLEDMatrix;
private updateGestures;
private updateMicrophone;
private updateRecordingActive;
private updateButtonAB;
private updatePin;
private updateTemperature;
private updateSoundLevel;
private updateHeading;
private lastFlashTime;
flashSystemLed(): void;
private lastAntennaFlash;
flashAntenna(): void;
private updateRSSI;
private updatePins;
private updateLightLevel;
private applyLightLevel;
findParentElement(): SVGSVGElement;
private updateTilt;
private buildDom;
private buildAntennaElement;
private buildSoundLevel;
private buildThermometerElement;
private buildLightLevelElement;
private buildHeadElement;
private buildPinElements;
private buildShakeElement;
private buildButtonElements;
private updateHardwareVersion;
private positionV2Elements;
private attachEvents;
private attachIFrameEvents;
private attachAccelerometerEvents;
private attachPinsIOEvents;
private attachPinsTouchEvents;
private attachABEvents;
attachButtonEvents(stateButton: Button, buttonOuter: SVGElement, elButton: SVGElement): void;
private attachAPlusBEvents;
private attachKeyboardEvents;
}
}
declare namespace pxsim {
function createMuteButton(): HTMLDivElement;
function shouldShowMute(): boolean;
function hasNavigator(): boolean;
function isEdge(): boolean;
function isIE(): boolean;
function isChrome(): boolean;
function isSafari(): boolean;
function isFirefox(): boolean;
}
declare namespace pxsim.pxtcore {
function registerWithDal(id: number, evid: number, handler: RefAction, mode?: number): void;
function deepSleep(): void;
}
declare namespace pxsim.BufferMethods {
function hash(buf: RefBuffer, bits: number): number;
}
declare namespace pxsim.control {
let runInParallel: typeof thread.runInBackground;
let delay: typeof thread.pause;
function reset(): void;
function singleSimulator(): void;
function waitMicros(micros: number): void;
function deviceName(): string;
function _ramSize(): number;
function deviceSerialNumber(): number;
function deviceLongSerialNumber(): RefBuffer;
function deviceDalVersion(): string;
function internalOnEvent(id: number, evid: number, handler: RefAction): void;
function waitForEvent(id: number, evid: number): void;
function allocateNotifyEvent(): number;
function raiseEvent(id: number, evid: number, mode: number): void;
function millis(): number;
function micros(): number;
function delayMicroseconds(us: number): void;
function createBuffer(size: number): RefBuffer;
function dmesg(msg: string): void;
function setDebugFlags(flags: number): void;
function heapSnapshot(): void;
function dmesgPtr(msg: string, ptr: any): void;
function dmesgValue(ptr: any): void;
function gc(): void;
function profilingEnabled(): boolean;
function __log(priority: number, str: string): void;
function heapDump(): void;
function isUSBInitialized(): boolean;
}
declare namespace pxsim {
const enum PXT_PANIC {
PANIC_CODAL_OOM = 20,
PANIC_GC_OOM = 21,
PANIC_GC_TOO_BIG_ALLOCATION = 22,
PANIC_CODAL_HEAP_ERROR = 30,
PANIC_CODAL_NULL_DEREFERENCE = 40,
PANIC_CODAL_USB_ERROR = 50,
PANIC_CODAL_HARDWARE_CONFIGURATION_ERROR = 90,
PANIC_INVALID_BINARY_HEADER = 901,
PANIC_OUT_OF_BOUNDS = 902,
PANIC_REF_DELETED = 903,
PANIC_SIZE = 904,
PANIC_INVALID_VTABLE = 905,
PANIC_INTERNAL_ERROR = 906,
PANIC_NO_SUCH_CONFIG = 907,
PANIC_NO_SUCH_PIN = 908,
PANIC_INVALID_ARGUMENT = 909,
PANIC_MEMORY_LIMIT_EXCEEDED = 910,
PANIC_SCREEN_ERROR = 911,
PANIC_MISSING_PROPERTY = 912,
PANIC_INVALID_IMAGE = 913,
PANIC_CALLED_FROM_ISR = 914,
PANIC_HEAP_DUMPED = 915,
PANIC_CAST_FIRST = 980,
PANIC_CAST_FROM_UNDEFINED = 980,
PANIC_CAST_FROM_BOOLEAN = 981,
PANIC_CAST_FROM_NUMBER = 982,
PANIC_CAST_FROM_STRING = 983,
PANIC_CAST_FROM_OBJECT = 984,
PANIC_CAST_FROM_FUNCTION = 985,
PANIC_CAST_FROM_NULL = 989
}
}
declare namespace pxsim.pxtcore {
function sendMessage(channel: string, message: RefBuffer, parentOnly?: boolean): void;
function peekMessageChannel(): string;
function readMessageData(): RefBuffer;
}
declare namespace pxsim {
const CONTROL_MESSAGE_EVT_ID = 2999;
const CONTROL_MESSAGE_RECEIVED = 1;
class ControlMessageState {
private board;
messages: SimulatorControlMessage[];
enabled: boolean;
constructor(board: CommonBoard);
private messageHandler;
enqueue(message: SimulatorControlMessage): void;
peek(): SimulatorControlMessage;
read(): SimulatorControlMessage;
}
interface ControlMessageBoard extends CommonBoard {
controlMessageState: ControlMessageState;
}
function getControlMessageState(): ControlMessageState;
}
declare namespace pxsim {
class AnalogSensorState {
id: number;
min: number;
max: number;
lowThreshold: number;
highThreshold: number;
sensorUsed: boolean;
private level;
private state;
constructor(id: number, min?: number, max?: number, lowThreshold?: number, highThreshold?: number);
setUsed(): void;
setLevel(level: number): void;
getLevel(): number;
setLowThreshold(value: number): void;
setHighThreshold(value: number): void;
private clampValue;
private setState;
}
}
declare namespace pxsim {
interface MicrophoneBoard {
microphoneState: MicrophoneState;
}
class MicrophoneState extends AnalogSensorState {
onSoundRegistered: boolean;
soundLevelRequested: boolean;
private pingUsed;
pingSoundLevel: () => void;
}
function microphoneState(): MicrophoneState;
}
declare namespace pxsim {
enum NeoPixelMode {
RGB = 1,
RGBW = 2,
RGB_RGB = 3,
DotStar = 4
}
class CommonNeoPixelState {
buffer: Uint8Array;
mode: number;
width: number;
get length(): number;
get stride(): 3 | 4;
pixelColor(pixel: number): number[];
}
interface CommonNeoPixelStateConstructor {
(pin: Pin): CommonNeoPixelState;
}
interface LightBoard {
tryGetNeopixelState(pinId: number): CommonNeoPixelState;
neopixelState(pinId: number): CommonNeoPixelState;
}
function neopixelState(pinId: number): CommonNeoPixelState;
function sendBufferAsm(buffer: RefBuffer, pin: number): void;
}
declare namespace pxsim.light {
function sendBuffer(pin: {
id: number;
}, clk: {
id: number;
}, mode: number, b: RefBuffer): void;
}
declare namespace pxsim.visuals {
function mkNeoPixelPart(xy?: Coord): SVGElAndSize;
class NeoPixel {
el: SVGElement;
cy: number;
constructor(xy?: Coord, width?: number);
setRgb(rgb: [number, number, number]): void;
}
class NeoPixelCanvas {
cols: number;
canvas: SVGSVGElement;
private pixels;
private viewBox;
private background;
constructor(pin: number, cols?: number);
private updateViewBox;
update(colors: number[][]): void;
setLoc(xy: Coord): void;
}
class NeoPixelView implements IBoardPart<CommonNeoPixelStateConstructor> {
parsePinString: (name: string) => Pin;
style: string;
element: SVGElement;
overElement: SVGElement;
defs: SVGElement[];
private state;
private canvas;
private part;
private stripGroup;
private lastLocation;
private pin;
constructor(parsePinString: (name: string) => Pin);
init(bus: EventBus, state: CommonNeoPixelStateConstructor, svgEl: SVGSVGElement, otherParams: Map<string>): void;
private makeCanvas;
moveToCoord(xy: Coord): void;
private updateStripLoc;
updateState(): void;
updateTheme(): void;
}
}
declare namespace pxsim.radio {
function raiseEvent(id: number, eventid: number): void;
function setGroup(id: number): void;
function setTransmitPower(power: number): void;
function setFrequencyBand(band: number): void;
function sendRawPacket(buf: RefBuffer): void;
function readRawPacket(): RefBuffer;
function onDataReceived(handler: RefAction): void;
function off(): void;
function on(): void;
}
declare namespace pxsim {
interface RadioBoard extends EventBusBoard {
radioState: RadioState;
}
function getRadioState(): RadioState;
interface PacketBuffer {
payload: SimulatorRadioPacketPayload;
rssi: number;
serial: number;
time: number;
}
interface SimulatorRadioPacketPayload {
bufferData?: Uint8Array;
}
interface RadioDAL {
ID_RADIO: number;
RADIO_EVT_DATAGRAM: number;
}
class RadioDatagram {
private runtime;
dal: RadioDAL;
datagram: PacketBuffer[];
lastReceived: PacketBuffer;
private _rssi;
constructor(runtime: Runtime, dal: RadioDAL);
get rssi(): number;
set rssi(value: number);
queue(packet: PacketBuffer): void;
send(payload: SimulatorRadioPacketPayload): void;
recv(): PacketBuffer;
onReceived(handler: RefAction): void;
private static defaultPacket;
}
class RadioState {
private readonly runtime;
private readonly board;
power: number;
transmitSerialNumber: boolean;
datagram: RadioDatagram;
groupId: number;
band: number;
enable: boolean;
constructor(runtime: Runtime, board: BaseBoard, dal: RadioDAL);
private handleMessage;
setGroup(id: number): void;
setTransmitPower(power: number): void;
setTransmitSerialNumber(sn: boolean): void;
setFrequencyBand(band: number): void;
off(): void;
on(): void;
raiseEvent(id: number, eventid: number): void;
receivePacket(packet: SimulatorRadioPacketMessage): void;
}
}
declare namespace pxsim.settings {
function _set(key: string, buf: RefBuffer): 0 | -1;
function _remove(key: string): 0 | -1;
function _exists(key: string): boolean;
function _get(key: string): RefBuffer;
function _userClean(): void;
function _list(prefix: string): RefCollection;
}