Note: This function is only available on the BBC micro:bit board

Get the current acceleration of the micro:bit from the on-board accelerometer

Get the analog value of the given pin

This is different to Arduino which only returns an integer between 0 and 1023

However only pins connected to an ADC will work (see the datasheet)

Note: if you didn't call pinMode beforehand then this function will also reset pin's state to "analog"

Set the analog Value of a pin. It will be output using PWM.

Objects can contain:

• freq - pulse frequency in Hz, eg. analogWrite(A0,0.5,{ freq : 10 }); - specifying a frequency will force PWM output, even if the pin has a DAC
• soft - boolean, If true software PWM is used if available.
• forceSoft - boolean, If true software PWM is used even

Note: if you didn't call pinMode beforehand then this function will also reset pin's state to "output"

A variable containing the arguments given to the function

Decode the supplied base64 string into a normal string

Note: This is only available in not devices with low flash memory

The Bluetooth Serial port - used when data is sent or received over Bluetooth Smart on nRF51/nRF52 chips.

Note: This is only available in devices with Bluetooth LE capability

Encode the supplied string (or array) into a base64 string

Note: This is only available in not devices with low flash memory

Change the Interval on a callback created with setInterval, for example:

var id = setInterval(function () { print('foo'); }, 1000); // every second

changeInterval(id, 1500); // now runs every 1.5 seconds

This takes effect immediately and resets the timeout, so in the example above, regardless of when you call changeInterval, the next interval will occur 1500ms after it.

Clear the Interval that was created with setInterval, for example:

var id = setInterval(function () { print('foo'); }, 1000);

clearInterval(id);

If no argument is supplied, all timers and intervals are stopped

Clear the Timeout that was created with setTimeout, for example:

var id = setTimeout(function () { print('foo'); }, 1000);

clearTimeout(id);

If no argument is supplied, all timers and intervals are stopped

Clear the Watch that was created with setWatch. If no parameter is supplied, all watches will be removed.

Note: This function is only available on the BBC micro:bit board

Get the current compass position for the micro:bit from the on-board magnetometer

Convert any groups of characters of the form '%ZZ', into characters with hex code '0xZZ'

Note: This is only available in not devices with low flash memory

Pulse the pin with the value for the given time in milliseconds. It uses a hardware timer to produce accurate pulses, and returns immediately (before the pulse has finished). Use digitalPulse(A0,1,0) to wait until a previous pulse has finished.

eg. digitalPulse(A0,1,5); pulses A0 high for 5ms. digitalPulse(A0,1,[5,2,4]); pulses A0 high for 5ms, low for 2ms, and high for 4ms

Note: if you didn't call pinMode beforehand then this function will also reset pin's state to "output"

digitalPulse is for SHORT pulses that need to be very accurate. If you're doing anything over a few milliseconds, use setTimeout instead.

Get the digital value of the given pin.

Note: if you didn't call pinMode beforehand then this function will also reset pin's state to "input"

If the pin argument is an array of pins (eg. [A2,A1,A0]) the value returned will be an number where the last array element is the least significant bit, for example if A0=A1=1 and A2=0, digitalRead([A2,A1,A0]) == 0b011

Set the digital value of the given pin.

Note: if you didn't call pinMode beforehand then this function will also reset pin's state to "output"

If pin argument is an array of pins (eg. [A2,A1,A0]) the value argument will be treated as an array of bits where the last array element is the least significant bit.

In this case, pin values are set least significant bit first (from the right-hand side of the array of pins). This means you can use the same pin multiple times, for example digitalWrite([A1,A1,A0,A0],0b0101) would pulse A0 followed by A1.

Output current interpreter state in a text form such that it can be copied to a new device

Note: 'Internal' functions are currently not handled correctly. You will need to recreate these in the onInit function.

Note: This is only available in not devices with low flash memory

Should TinyJS echo what you type back to you? true = yes (Default), false = no. When echo is off, the result of executing a command is not returned. Instead, you must use 'print' to send output.

Fill the console with the contents of the given function, so you can edit it.

NOTE: This is a convenience function - it will not edit 'inner functions'. For that, you must edit the 'outer function' and re-execute it.

Convert a string with any character not alphanumeric or - _ . ! ~ * ' ( ) converted to the form %XY where XY is its hexadecimal representation

Note: This is only available in not devices with low flash memory

Evaluate a string containing JavaScript code

Return the current mode of the given pin. See pinMode for more information on returned values.

Note: This is only available in not devices with low flash memory

Get the serial number of this board

Return the current system time in Seconds (as a floating point number)

A reference to the global scope, where everything is defined.

The first I2C port

The second I2C port

The third I2C port

Whether the x is NaN (Not a Number) or not

Restart and load the program out of flash - this has an effect similar to completely rebooting Espruino (power off/power on), but without actually performing a full reset of the hardware.

This command only executes when the Interpreter returns to the Idle state - for instance a=1;load();a=2; will still leave 'a' as undefined (or what it was set to in the saved program).

Espruino will resume from where it was when you last typed save(). If you want code to be executed right after loading (for instance to initialise devices connected to Espruino), add an init event handler to E with E.on('init', function() { ... your_code ... });. This will then be automatically executed by Espruino every time it starts.

A loopback serial device. Data sent to LoopbackA comes out of LoopbackB and vice versa

A loopback serial device. Data sent to LoopbackA comes out of LoopbackB and vice versa

Convert a string representing a number into an float

Convert a string representing a number into an integer

Read 16 bits of memory at the given location - DANGEROUS!

Read 32 bits of memory at the given location - DANGEROUS!

Read 8 bits of memory at the given location - DANGEROUS!

Set the mode of the given pin.

• auto/undefined - Don't change state, but allow digitalWrite/etc to automatically change state as appropriate
• analog - Analog input
• input - Digital input
• input_pullup - Digital input with internal ~40k pull-up resistor
• input_pulldown - Digital input with internal ~40k pull-down resistor
• output - Digital output
• opendrain - Digital output that only ever pulls down to 0v. Sending a logical 1 leaves the pin open circuit
• opendrain_pullup - Digital output that pulls down to 0v. Sending a logical 1 enables internal ~40k pull-up resistor
• af_output - Digital output from built-in peripheral
• af_opendrain - Digital output from built-in peripheral that only ever pulls down to 0v. Sending a logical 1 leaves the pin open circuit

Note: digitalRead/digitalWrite/etc set the pin mode automatically unless pinMode has been called first. If you want digitalRead/etc to set the pin mode automatically after you have called pinMode, simply call it again with no mode argument (pinMode(pin)), auto as the argument (pinMode(pin, "auto")), or with the 3rd 'automatic' argument set to true (pinMode(pin, "output", true)).

Write 16 bits of memory at the given location - VERY DANGEROUS!

Write 32 bits of memory at the given location - VERY DANGEROUS!

Write 8 bits of memory at the given location - VERY DANGEROUS!

Print the supplied string(s) to the console

Note: If you're connected to a computer (not a wall adaptor) via USB but you are not running a terminal app then when you print data Espruino may pause execution and wait until the computer requests the data it is trying to print.

Load the given module, and return the exported functions

Reset the interpreter - clear program memory, and do not load a saved program from flash. This does NOT reset the underlying hardware (which allows you to reset the device without it disconnecting from USB).

This command only executes when the Interpreter returns to the Idle state - for instance a=1;reset();a=2; will still leave 'a' as undefined.

The safest way to do a full reset is to hit the reset button.

Save program memory into flash. It will then be loaded automatically every time Espruino powers on or is hard-reset.

This command only executes when the Interpreter returns to the Idle state - for instance a=1;save();a=2; will save 'a' as 2.

When Espruino powers on, it will resume from where it was when you typed save(). If you want code to be executed right after loading (for instance to initialise devices connected to Espruino), add an init event handler to E with E.on('init', function() { ... your_code ... });. This will then be automatically executed by Espruino every time it starts.

In order to stop the program saved with this command being loaded automatically, hold down Button 1 while also pressing reset. On some boards, Button 1 enters bootloader mode, so you will need to press Reset with Button 1 raised, and then hold Button 1 down a fraction of a second later.

The first Serial (USART) port

The second Serial (USART) port

The third Serial (USART) port

The fourth Serial (USART) port

The fifth Serial (USART) port

The sixth Serial (USART) port

When Espruino is busy, set the pin specified here high. Set this to undefined to disable the feature.

Set whether we can enter deep sleep mode, which reduces power consumption to around 100uA. This only works on the Espruino Board.

Please see http://www.espruino.com/Power+Consumption for more details on this.

Call the function (or evaluate the string) specified REPEATEDLY after the timeout in milliseconds.

For instance:

setInterval(function () {
  console.log("Hello World");
}, 1000);
// or
setInterval('console.log("Hello World");', 1000);
// both print 'Hello World' every second

You can also specify extra arguments that will be sent to the function when it is executed. For example:

setInterval(function (a,b) {
  console.log(a+" "+b);
}, 1000, "Hello", "World");
// prints 'Hello World' every second

If you want to stop your function from being called, pass the number that was returned by setInterval into the clearInterval function.

Note: If setDeepSleep(true) has been called and the interval is greater than 5 seconds, Espruino may execute the interval up to 1 second late. This is because Espruino can only wake from deep sleep every second - and waking early would cause Espruino to waste power while it waited for the correct time.

When Espruino is asleep, set the pin specified here low (when it's awake, set it high). Set this to undefined to disable the feature.

Please see http://www.espruino.com/Power+Consumption for more details on this.

Set the current system time in seconds (to the nearest second)

Call the function (or evaluate the string) specified ONCE after the timeout in milliseconds.

For instance:

setTimeout(function () {
  console.log("Hello World");
}, 1000);
// or
setTimeout('console.log("Hello World");', 1000);
// both print 'Hello World' after a second

You can also specify extra arguments that will be sent to the function when it is executed. For example:

setTimeout(function (a,b) {
  console.log(a+" "+b);
}, 1000, "Hello", "World");
// prints 'Hello World' after 1 second

If you want to stop the function from being called, pass the number that was returned by setTimeout into the clearInterval function.

Note: If setDeepSleep(true) has been called and the interval is greater than 5 seconds, Espruino may execute the interval up to 1 second late. This is because Espruino can only wake from deep sleep every second - and waking early would cause Espruino to waste power while it waited for the correct time.

Call the function specified when the pin changes. Watches set with setWatch can be removed using clearWatch.

The function may also take an argument, which is an object of type {state:bool, time:float, lastTime:float}.

• state is whether the pin is currently a 1 or a 0
• time is the time in seconds at which the pin changed state
• lastTime is the time in seconds at which the pin last changed state. When using edge:'rising' or edge:'falling', this is not the same as when the function was last called.

For instance, if you want to measure the length of a positive pulse you could use setWatch(function(e) { console.log(e.time-e.lastTime); }, BTN, { repeat:true, edge:'falling' });. This will only be called on the falling edge of the pulse, but will be able to measure the width of the pulse because e.lastTime is the time of the rising edge.

Internally, an interrupt writes the time of the pin's state change into a queue, and the function supplied to setWatch is executed only from the main message loop. However, if the callback is a native function void (bool state) then you can add irq:true to options, which will cause the function to be called from within the IRQ. When doing this, interrupts will happen on both edges and there will be no debouncing.

Note: The STM32 chip (used in the Espruino Board and Pico) cannot watch two pins with the same number - eg A0 and B0.

Shift an array of data out using the pins supplied least significant bit first, for example:

``` // shift out to single clk+data shiftOut(A0, { clk : A1 }, [1,0,1,0]);

// shift out a whole byte (like software SPI) shiftOut(A0, { clk : A1, repeat: 8 }, [1,2,3,4]);

// shift out via 4 data pins shiftOut([A3,A2,A1,A0], { clk : A4 }, [1,2,3,4]); ```

options is an object of the form:

{
  clk : pin, // a pin to use as the clock (undefined = no pin)
  clkPol : bool, // clock polarity - default is 0 (so 1 normally, pulsing to 0 to clock data in)
  repeat : int, // number of clocks per array item
}

Each item in the data array will be output to the pins, with the first pin in the array being the MSB and the last the LSB, then the clock will be pulsed in the polarity given.

repeat is the amount of times shift data out for each array item. For instance we may want to shift 8 bits out through 2 pins - in which case we need to set repeat to 4.

Note: This function is only available on the BBC micro:bit board

Show an image on the in-built 5x5 LED screen.

Image can be:

• A number where each bit represents a pixel (so 25 bits). eg. 5 or 0x1FFFFFF
• A string, eg: show("10001"). Newlines are ignored, and anything that is not a space or 0 is treated as a 1.
• An array of 4 bytes (more will be ignored), eg show([1,2,3,0])

For instance the following works for images:

show("#   #"+
     "  #  "+
     "  #  "+
     "#   #"+
     " ### ")

This means you can also use Espruino's graphics library:

var g = Graphics.createArrayBuffer(5,5,1)
g.drawString("E",0,0)
show(g.buffer)

The first SPI port

The second SPI port

The third SPI port

A telnet serial device that maps to the built-in telnet console server (devices that have built-in wifi only).

Output debugging information

Note: This is only available in not devices with low flash memory

The USB Serial port

Note: This is only available in devices with USB

Class containing AES encryption/decryption

Note: This library is currently only included in builds for the Espruino Pico and Espruino WiFi. For other boards you will have to make build your own firmware, and you may need to remove other features in order to make room.

This is the built-in JavaScript class for arrays.

Arrays can be defined with [], new Array(), or new Array(length)

Create an Array. Either give it one integer argument (>=0) which is the length of the array, or any number of arguments

Create a new array, containing the elements from this one and any arguments, if any argument is an array then those elements will be added.

Note: This is only available in not devices with low flash memory

Return 'true' if the callback returns 'true' for every element in the array

Fill this array with the given value, for every index >= start and < end

Note: This is only available in not devices with low flash memory

Return an array which contains only those elements for which the callback function returns 'true'

Executes a provided function once per array element.

Return the index of the value in the array, or -1

Returns true if the provided object is an array

Join all elements of this array together into one string, using 'separator' between them. eg. [1,2,3].join(' ')=='1 2 3'

Find the length of the array

Return an array which is made from the following: A.map(function) = [function(A[0]), function(A[1]), ...]

Remove and return the value on the end of this array.

This is the opposite of [1,2,3].shift(), which removes an element from the beginning of the array.

Push a new value onto the end of this array'

This is the opposite of [1,2,3].unshift(0), which adds one or more elements to the beginning of the array.

Execute previousValue=initialValue and then previousValue = callback(previousValue, currentValue, index, array) for each element in the array, and finally return previousValue.

Note: This is only available in not devices with low flash memory

Reverse all elements in this array (in place)

Note: This is only available in not devices with low flash memory

Remove and return the first element of the array.

This is the opposite of [1,2,3].pop(), which takes an element off the end.

Note: This is only available in not devices with low flash memory

Return a copy of a portion of this array (in a new array)

Return 'true' if the callback returns 'true' for any of the elements in the array

Do an in-place quicksort of the array

Note: This is only available in not devices with low flash memory

Both remove and add items to an array

Convert the Array to a string

Add one or more items to the start of the array, and return its new length.

This is the opposite of [1,2,3].push(4), which puts one or more elements on the end.

Note: This is only available in not devices with low flash memory

This is the built-in JavaScript class for array buffers.

Create an Array Buffer object

This is the built-in JavaScript class that is the prototype for Uint8Array / Float32Array / etc

The buffer this view references

The length, in bytes, of the view

The offset, in bytes, to the first byte of the view within the ArrayBuffer

Fill this array with the given value, for every index >= start and < end

Note: This is only available in not devices with low flash memory

Executes a provided function once per array element.

Return the index of the value in the array, or -1

Join all elements of this array together into one string, using 'separator' between them. eg. [1,2,3].join(' ')=='1 2 3'

Return an array which is made from the following: A.map(function) = [function(A[0]), function(A[1]), ...]

Note: This returns an ArrayBuffer of the same type it was called on. To get an Array, use Array.prototype.map

Execute previousValue=initialValue and then previousValue = callback(previousValue, currentValue, index, array) for each element in the array, and finally return previousValue.

Note: This is only available in not devices with low flash memory

Reverse the contents of this arraybuffer in-place

Note: This is only available in not devices with low flash memory

Copy the contents of array into this one, mapping this[x+offset]=array[x];

Return a copy of a portion of this array (in a new array).

Note: This currently returns a normal Array, not an ArrayBuffer

Note: This is only available in not devices with low flash memory

Do an in-place quicksort of the array

Note: This is only available in not devices with low flash memory

Web Bluetooth-style device - get this using NRF.requestDevice(address)

Note: This is only available on some devices

Note: This is only available in NRF52 devices (like Puck.js)

Web Bluetooth-style GATT characteristic - get this using BluetoothRemoteGATTService.getCharacteristic(s)

https://webbluetoothcg.github.io/web-bluetooth/#bluetoothremotegattcharacteristic

Read a characteristic's value

var device;
NRF.connect(device_address).then(function(d) {
  device = d;
  return d.getPrimaryService("service_uuid");
}).then(function(s) {
  console.log("Service ",s);
  return s.getCharacteristic("characteristic_uuid");
}).then(function(c) {
  return c.readValue();
}).then(function(d) {
  console.log("Got:", JSON.stringify(d));
  device.disconnect();
}).catch(function() {
  console.log("Something's broken.");
});

Note: This is only available on some devices

Starts notifications - whenever this characteristic's value changes, a characteristicvaluechanged event is fired.

var device;
NRF.connect(device_address).then(function(d) {
  device = d;
  return d.getPrimaryService("service_uuid");
}).then(function(s) {
  console.log("Service ",s);
  return s.getCharacteristic("characteristic_uuid");
}).then(function(c) {
  c.on('characteristicvaluechanged', function(event) {
    console.log("-> "+event.target.value);
  });
  return c.startNotifications();
}).then(function(d) {
  console.log("Waiting for notifications"));
}).catch(function() {
  console.log("Something's broken.");
});

Note: This is only available on some devices

Note: This is only available on some devices

Write a characteristic's value

var device;
NRF.connect(device_address).then(function(d) {
  device = d;
  return d.getPrimaryService("service_uuid");
}).then(function(s) {
  console.log("Service ",s);
  return s.getCharacteristic("characteristic_uuid");
}).then(function(c) {
  return c.writeValue("Hello");
}).then(function(d) {
  device.disconnect();
}).catch(function() {
  console.log("Something's broken.");
});

Note: This is only available on some devices

Web Bluetooth-style GATT server - get this using NRF.connect(address) or NRF.requestDevice(options) then response.gatt.connect

https://webbluetoothcg.github.io/web-bluetooth/#bluetoothremotegattserver

Connect to a BLE device - returns a promise, the argument of which is the BluetoothRemoteGATTServer connection.

See NRF.requestDevice for usage examples.

Note: This is only available on some devices

Note: This is only available in NRF52 devices (like Puck.js)

Disconnect from a previously connected BLE device connected with NRF.connect - this does not disconnect from something that has connected to the Espruino.

Note: This is only available on some devices

Note: This is only available in NRF52 devices (like Puck.js)

Note: This is only available on some devices

Note: This is only available in NRF52 devices (like Puck.js)

Note: This is only available on some devices

Note: This is only available in NRF52 devices (like Puck.js)

Web Bluetooth-style GATT service - get this using BluetoothRemoteGATTServer.getPrimaryService(s)

https://webbluetoothcg.github.io/web-bluetooth/#bluetoothremotegattservice

Note: This is only available on some devices

Note: This is only available in NRF52 devices (like Puck.js)

Note: This is only available on some devices

Note: This is only available in NRF52 devices (like Puck.js)

Creates a boolean

Initialise the CC3000 and return a WLAN object

An Object that contains functions for writing to the interactive console

Print the supplied string(s) to the console

Note: If you're connected to a computer (not a wall adaptor) via USB but you are not running a terminal app then when you print data Espruino may pause execution and wait until the computer requests the data it is trying to print.

Cryptographic functions

Note: This library is currently only included in builds for the Espruino Pico and Espruino WiFi. For other boards you will have to make build your own firmware, and you may need to remove other features in order to make room.

Class containing AES encryption/decryption

Note: This is only available in devices that support AES (Espruino Pico, Espruino WiFi or Linux)

Password-Based Key Derivation Function 2 algorithm, using SHA512

Note: This is only available in devices with TLS and SSL support (Espruino Pico and Espruino WiFi only)

Performs a SHA1 hash and returns the result as a 20 byte ArrayBuffer

Note: This is only available in devices that support Crypto Functionality (Espruino Pico, Espruino WiFi, Linux or ESP8266)

Performs a SHA224 hash and returns the result as a 28 byte ArrayBuffer

Note: This is only available in devices that support Crypto Functionality (Espruino Pico, Espruino WiFi, Linux or ESP8266)

Performs a SHA256 hash and returns the result as a 32 byte ArrayBuffer

Note: This is only available in devices that support Crypto Functionality (Espruino Pico, Espruino WiFi, Linux or ESP8266)

Performs a SHA384 hash and returns the result as a 48 byte ArrayBuffer

Note: This is only available in devices that support Crypto Functionality (Espruino Pico, Espruino WiFi, Linux or ESP8266)

Performs a SHA512 hash and returns the result as a 64 byte ArrayBuffer

Note: This is only available in devices that support Crypto Functionality (Espruino Pico, Espruino WiFi, Linux or ESP8266)

The built-in class for handling Dates

Creates a date object

Day of the month 1..31

Day of the week (0=sunday, 1=monday, etc)

The year, eg. 2014

0..23

0..999

0..59

Month of the year 0..11

0..59

Return the number of milliseconds since 1970

The getTimezoneOffset() method returns the time-zone offset from UTC, in minutes, for the current locale.

Get the number of milliseconds elapsed since 1970 (or on embedded platforms, since startup)

Parse a date string and return milliseconds since 1970. Data can be either '2011-10-20T14:48:00', '2011-10-20' or 'Mon, 25 Dec 1995 13:30:00 +0430'

Converts to a ISO 8601 String, eg: 2014-06-20T14:52:20.123Z

Note: This always assumes a timezone of GMT

Converts to a String, eg: Fri Jun 20 2014 14:52:20 GMT+0000

Note: This always assumes a timezone of GMT+0000

Converts to a String, eg: Fri, 20 Jun 2014 14:52:20 GMT

Note: This always assumes a timezone of GMT

Return the number of milliseconds since 1970

This is the built-in JavaScript class for Espruino utility functions.

Clip a number to be between min and max (inclusive)

Note: This is only available in not devices with low flash memory

Setup the filesystem so that subsequent calls to E.openFile and require('fs').* will use an SD card on the supplied SPI device and pin.

It can even work using software SPI - for instance:

var spi = new SPI();
spi.setup({mosi:C7,miso:C8,sck:C9});
E.connectSDCard(spi,C6);
console.log(require("fs").readdirSync());

Note: This is only available in not devices with low flash memory

Convolve arr1 with arr2. This is equivalent to v=0;for (i in arr1) v+=arr1[i] * arr2[(i+offset) % arr2.length]

Note: This is only available in not devices with low flash memory

Dump any locked variables that aren't referenced from global - for debugging memory leaks only.

Note: This is only available in not release builds

Get the current interpreter state in a text form such that it can be copied to a new device

Note: This is only available in not devices with low flash memory

Output the current list of Utility Timer Tasks - for debugging only

Note: This is only available in not release builds

Enable the watchdog timer. This will reset Espruino if it isn't able to return to the idle loop within the timeout.

If isAuto is false, you must call E.kickWatchdog() yourself every so often or the chip will reset.

NOTE: This will not work with setDeepSleep unless you explicitly wake Espruino up with an interval of less than the timeout.

NOTE: This is only implemented on STM32 devices.

Note: This is only available in not devices with low flash memory

Performs a Fast Fourier Transform (fft) on the supplied data and writes it back into the original arrays. Note that if only one array is supplied, the data written back is the modulus of the complex result sqrt(r*r+i*i).

Note: This is only available in not devices with low flash memory

Check the internal voltage reference. To work out an actual voltage of an input pin, you can use analogRead(pin)*E.getAnalogVRef()

Note: This value is calculated by reading the voltage on an internal voltage reference with the ADC. It will be slightly noisy, so if you need this for accurate measurements we'd recommend that you call this function several times and average the results.

While this is implemented on Espruino boards, it may not be implemented on other devices. If so it'll return NaN.

Note: This is only available in not devices with low flash memory

Get and reset the error flags. Returns an array that can contain:

'FIFO_FULL': The receive FIFO filled up and data was lost. This could be state transitions for setWatch, or received characters.

'BUFFER_FULL': A buffer for a stream filled up and characters were lost. This can happen to any stream - Serial,HTTP,etc.

'CALLBACK': A callback (setWatch, setInterval, on('data',...)) caused an error and so was removed.

'LOW_MEMORY': Memory is running low - Espruino had to run a garbage collection pass or remove some of the command history

'MEMORY': Espruino ran out of memory and was unable to allocate some data that it needed.

Note: This is only available in not devices with low flash memory

Return the number of variable blocks used by the supplied variable. This is useful if you're running out of memory and you want to be able to see what is taking up most of the available space.

If depth>0 and the variable can be recursed into, an array listing all property names (including internal Espruino names) and their sizes is returned. If depth>1 there is also a more field that inspects the objects's children's children.

For instance E.getSizeOf(function(a,b) { }) returns 5.

But E.getSizeOf(function(a,b) { }, 1) returns:

[
  {
    "name": "a",
    "size": 1 },
  {
    "name": "b",
    "size": 1 },
  {
    "name": "\xFFcod",
    "size": 2 }
 ]

In this case setting depth to 2 will make no difference as there are no more children to traverse.

See http://www.espruino.com/Internals for more information

Note: This is only available in not devices with low flash memory

Use the STM32's internal thermistor to work out the temperature.

While this is implemented on Espruino boards, it may not be implemented on other devices. If so it'll return NaN.

Note: This is not entirely accurate and varies by a few degrees from chip to chip. It measures the die temperature, so when connected to USB it could be reading 10 over degrees C above ambient temperature. When running from battery with setDeepSleep(true) it is much more accurate though.

Convert hue, saturation and brightness to red, green and blue (packed into an integer)

This replaces Graphics.setColorHSB and Graphics.setBgColorHSB. On devices with 24 bit colour it can be used as: Graphics.setColorHSB(E.HSBtoRGB(h, s, b))

Note: This is only available in not devices with low flash memory

Unlike 'Math.random()' which uses a pseudo-random number generator, this method reads from the internal voltage reference several times, xoring and rotating to try and make a relatively random value from the noise in the signal.

Note: This is only available in not devices with low flash memory

This event is called right after the board starts up, and has a similar effect to creating a function called onInit.

For example to write "Hello World" every time Espruino starts, use:

E.on('init', function() {
  console.log("Hello World!");
});

Note: that subsequent calls to E.on('init', will add a new handler, rather than replacing the last one. This allows you to write modular code - something that was not possible with onInit.

Interpolate between two adjacent values in the Typed Array

Note: This is only available in not devices with low flash memory

Interpolate between four adjacent values in the Typed Array, in 2D.

Note: This is only available in not devices with low flash memory

Kicks a Watchdog timer set up with E.enableWatchdog(..., false). See E.enableWatchdog for more information.

NOTE: This is only implemented on STM32 devices.

Note: This is only available in not devices with low flash memory

If a password has been set with E.setPassword(), this will lock the console so the password needs to be entered to unlock it.

Take each element of the from array, look it up in map (or call the function with it as a first argument), and write it into the corresponding element in the to array.

Note: This is only available in not devices with low flash memory

This creates and returns a special type of string, which actually references a specific memory address. It can be used in order to use sections of Flash memory directly in Espruino (for example to execute code straight from flash memory with eval(E.memoryArea( ... )))

Note: This is only tested on STM32-based platforms (Espruino Original and Espruino Pico) at the moment.

ADVANCED: This is a great way to crash Espruino if you're not sure what you are doing

Create a native function that executes the code at the given address. Eg. E.nativeCall(0x08012345,'double (double,double)')(1.1, 2.2)

If you're executing a thumb function, you'll almost certainly need to set the bottom bit of the address to 1.

Note it's not guaranteed that the call signature you provide can be used - there are limits on the number of arguments allowed.

When supplying data, if it is a 'flat string' then it will be used directly, otherwise it'll be converted to a flat string and used.

Note: This is only available in not devices with low flash memory

Open a file

Reverse the 8 bits in a byte, swapping MSB and LSB.

For example, E.reverseByte(0b10010000) == 0b00001001.

Note that you can reverse all the bytes in an array with: arr = arr.map(E.reverseByte)

Note: This is only available in not devices with low flash memory

This writes JavaScript code into Espruino's flash memory, to be executed on startup. It differs from save() in that save() saves the whole state of the interpreter, whereas this just saves JS code that is executed at boot.

Code will be executed before onInit() and E.on('init', ...).

If alwaysExec is true, the code will be executed even after a call to reset(). This is useful if you're making something that you want to program, but you want some code that is always built in (for instance setting up a display or keyboard).

To remove boot code that has been saved previously, use E.setBootCode("")

Note: this removes any code that was previously saved with save()

This sets the clock frequency of Espruino's processor. It will return 0 if it is unimplemented or the clock speed cannot be changed.

Note: On pretty much all boards, UART, SPI, I2C, PWM, etc will change frequency and will need setting up again in order to work.

STM32F4

Options is of the form { M: int, N: int, P: int, Q: int } - see the 'Clocks' section of the microcontroller's reference manual for what these mean.

• System clock = 8Mhz * N / ( M * P )
• USB clock (should be 48Mhz) = 8Mhz * N / ( M * Q )

Optional arguments are:

• latency - flash latency from 0..15
• PCLK1 - Peripheral clock 1 divisor (default: 2)
• PCLK2 - Peripheral clock 2 divisor (default: 4)

The Pico's default is {M:8, N:336, P:4, Q:7, PCLK1:2, PCLK2:4}, use {M:8, N:336, P:8, Q:7, PCLK:1, PCLK2:2} to halve the system clock speed while keeping the peripherals running at the same speed (omitting PCLK1/2 will lead to the peripherals changing speed too).

On STM32F4 boards (eg. Espruino Pico), the USB clock needs to be kept at 48Mhz or USB will fail to work. You'll also experience USB instability if the processor clock falls much below 48Mhz.

ESP8266

Just specify an integer value, either 80 or 160 (for 80 or 160Mhz)

Note: This is only available in not devices with low flash memory

Set a password on the console (REPL). When powered on, Espruino will then demand a password before the console can be used. If you want to lock the console immediately after this you can call E.lockConsole()

To remove the password, call this function with no arguments.

Note: There is no protection against multiple password attempts, so someone could conceivably try every password in a dictionary.

Note: This password is stored in memory in plain text. If someone is able to execute arbitrary JavaScript code on the device (eg, you use eval on input from unknown sources) or read the device's firmware then they may be able to obtain it.

USB HID will only take effect next time you unplug and re-plug your Espruino. If you're disconnecting it from power you'll have to make sure you have save()d after calling this function.

Note: This is only available in devices that support USB HID (Espruino Pico and Espruino WiFi)

Set the seed for the random number generator used by Math.random().

Note: This is only available in not devices with low flash memory

Sum the contents of the given Array, String or ArrayBuffer and return the result

Note: This is only available in not devices with low flash memory

Create an ArrayBuffer from the given string. This is done via a reference, not a copy - so it is very fast and memory efficient.

Note that this is an ArrayBuffer, not a Uint8Array. To get one of those, do: new Uint8Array(E.toArrayBuffer('....')).

Returns a 'flat' string representing the data in the arguments.

This creates a string from the given arguments. If an argument is a String or an Array, each element is traversed and added as an 8 bit character. If it is anything else, it is converted to a character directly.

This creates a Uint8Array from the given arguments. If an argument is a String or an Array, each element is traversed and added as if it were an 8 bit value. If it is anything else, it is converted to an 8 bit value directly.

Unmount the SD card, so it can be removed. If you remove the SD card without calling this you may cause corruption, and you will be unable to access another SD card until you reset Espruino or call E.unmountSD().

Work out the variance of the contents of the given Array, String or ArrayBuffer and return the result. This is equivalent to v=0;for (i in arr) v+=Math.pow(mean-arr[i],2)

Note: This is only available in not devices with low flash memory

The base class for runtime errors

Creates an Error object

The ESP8266 library is specific to the ESP8266 version of Espruino, i.e., running Espruino on an ESP8266 module (not to be confused with using the ESP8266 as Wifi add-on to an Espruino board). This library contains functions to handle ESP8266-specific actions. For example: var esp8266 = require('ESP8266'); esp8266.reboot(); performs a hardware reset of the module.

Put the ESP8266 into 'deep sleep' for the given number of microseconds, reducing power consumption drastically.

Note: unlike normal Espruino boards' 'deep sleep' mode, ESP8266 deep sleep actually turns off the processor. After the given number of microseconds have elapsed, the ESP8266 will restart as if power had been turned off and then back on. All contents of RAM will be lost.

Dumps info about all sockets to the log. This is for troubleshooting the socket implementation.

Note: This is deprecated. Use require("flash").getFree()

At boot time the esp8266's firmware captures the cause of the reset/reboot. This function returns this information in an object with the following fields:

• reason: "power on", "wdt reset", "exception", "soft wdt", "restart", "deep sleep", or "reset pin"
• exccause: exception cause
• epc1, epc2, epc3: instruction pointers
• excvaddr: address being accessed
• depc: (?)

Returns an object that contains details about the state of the ESP8266 with the following fields:

• sdkVersion - Version of the SDK.
• cpuFrequency - CPU operating frequency in Mhz.
• freeHeap - Amount of free heap in bytes.
• maxCon - Maximum number of concurrent connections.
• flashMap - Configured flash size&map: '512KB:256/256' .. '4MB:512/512'
• flashKB - Configured flash size in KB as integer
• flashChip - Type of flash chip as string with manufacturer & chip, ex: '0xEF 0x4016`

Enable or disable the logging of debug information. A value of true enables debug logging while a value of false disables debug logging. Debug output is sent to UART1 (gpio2).

Perform a network ping request. The parameter can be either a String or a numeric IP address. Note: This function should probably be removed, or should it be part of the wifi library?

Prints the contents of the debug log to the console.

Returns one line from the log or up to 128 characters.

Perform a hardware reset/reboot of the esp8266.

Note: This is deprecated. Use E.setClock(80/160) Note: Set the operating frequency of the ESP8266 processor. The default is 160Mhz.

Warning: changing the cpu frequency affects the timing of some I/O operations, notably of software SPI and I2C, so things may be a bit slower at 80Mhz.

Set the debug logging mode. It can be disabled (which frees ~1.2KB of heap), enabled in-memory only, or in-memory and output to a UART.

An instantiation of an Ethernet network adaptor

Get the current IP address, subnet, gateway and mac address.

Set the current IP address or get an IP from DHCP (if no options object is specified)

If 'mac' is specified as an option, it must be a string of the form "00:01:02:03:04:05"

This is the File object - it allows you to stream data to and from files (As opposed to the require('fs').readFile(..) style functions that read an entire file).

To create a File object, you must type var fd = E.openFile('filepath','mode') - see E.openFile for more information.

Note: If you want to remove an SD card after you have started using it, you must call E.unmountSD() or you may cause damage to the card.

Close an open file.

Pipe this file to a stream (an object with a 'write' method)

Note: This is only available in not devices with low flash memory

Read data in a file in byte size chunks

Seek to a certain position in the file

Skip the specified number of bytes forward in the file

write data to a file

This module allows access to read and write the STM32's flash memory.

It should be used with extreme caution, as it is easy to overwrite parts of Flash memory belonging to Espruino or even its bootloader. If you damage the bootloader then you may need external hardware such as a USB-TTL converter to restore it. For more information on restoring the bootloader see Advanced Reflashing in your board's reference pages.

To see which areas of memory you can and can't overwrite, look at the values reported by process.memory().

Erase a page of flash memory

Note: This is only available in not devices with low flash memory

This method returns an array of objects of the form {addr : #, length : #}, representing contiguous areas of flash memory in the chip that are not used for anything.

The memory areas returned are on page boundaries. This means that you can safely erase the page containing any address here, and you won't risk deleting part of the Espruino firmware.

Note: This is only available in not devices with low flash memory

Returns the start and length of the flash page containing the given address.

Note: This is only available in not devices with low flash memory

Read flash memory from the given address

Note: This is only available in not devices with low flash memory

Write data into memory at the given address - IN MULTIPLES OF 4 BYTES.

In flash memory you may only turn bits that are 1 into bits that are 0. If you're writing data into an area that you have already written (so read doesn't return all 0xFF) you'll need to call erasePage to clear the entire page.

Note: This is only available in not devices with low flash memory

This is the built-in JavaScript class for a typed array.

Instantiate this in order to efficiently store arrays of data (Espruino's normal arrays store data in a map, which is inefficient for non-sparse arrays).

Create a typed array based on the given input. Either an existing Array Buffer, an Integer as a Length, or a simple array. If an ArrayBuffer view (eg. Uint8Array rather than ArrayBuffer) is given, it will be completely copied rather than referenced.

This is the built-in JavaScript class for a typed array.

Instantiate this in order to efficiently store arrays of data (Espruino's normal arrays store data in a map, which is inefficient for non-sparse arrays).

Create a typed array based on the given input. Either an existing Array Buffer, an Integer as a Length, or a simple array. If an ArrayBuffer view (eg. Uint8Array rather than ArrayBuffer) is given, it will be completely copied rather than referenced.

This library handles interfacing with a FAT32 filesystem on an SD card. The API is designed to be similar to node.js's - However Espruino does not currently support asynchronous file IO, so the functions behave like node.js's xxxxSync functions. Versions of the functions with 'Sync' after them are also provided for compatibility.

Currently this provides minimal file IO - it's great for logging and loading/saving settings, but not good for loading large amounts of data as you will soon fill your memory up.

It is currently only available on boards that contain an SD card slot, such as the Olimexino and the HY. It can not currently be added to boards that did not ship with a card slot.

To use this, you must type var fs = require('fs') to get access to the library

Append the data to the given file, created a new file if it doesn't exist

NOTE: Espruino does not yet support Async file IO, so this function behaves like the 'Sync' version.

Append the data to the given file, created a new file if it doesn't exist

Note: This is only available in not devices with low flash memory

List all files in the supplied directory, returning them as an array of strings.

NOTE: Espruino does not yet support Async file IO, so this function behaves like the 'Sync' version.

List all files in the supplied directory, returning them as an array of strings.

Note: This is only available in not devices with low flash memory

Read all data from a file and return as a string

NOTE: Espruino does not yet support Async file IO, so this function behaves like the 'Sync' version.

Read all data from a file and return as a string.

Note: The size of files you can load using this method is limited by the amount of available RAM. To read files a bit at a time, see the File class.

Note: This is only available in not devices with low flash memory

Return information on the given file. This returns an object with the following fields:

size: size in bytes dir: a boolean specifying if the file is a directory or not mtime: A Date structure specifying the time the file was last modified

Note: This is only available in not devices with low flash memory

Delete the given file

NOTE: Espruino does not yet support Async file IO, so this function behaves like the 'Sync' version.

Note: This is only available in not devices with low flash memory

Delete the given file

Note: This is only available in not devices with low flash memory

Write the data to the given file

NOTE: Espruino does not yet support Async file IO, so this function behaves like the 'Sync' version.

Write the data to the given file

Note: This is only available in not devices with low flash memory

This is the built-in class for Functions

This executes the function with the supplied 'this' argument and parameters

This executes the function with the supplied 'this' argument and parameters