/*JSON{
"type" : "function",
"name" : "setTimeout",
"generate" : "jswrap_interface_setTimeout",
"params" : [
["function","JsVar","A Function or String to be executed"],
["timeout","float","The time until the function will be executed"],
["args","JsVarArray","Optional arguments to pass to the function when executed"]
],
"return" : ["JsVar","An ID that can be passed to clearTimeout"]
}
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.
*/
JsVar *_jswrap_interface_setTimeoutOrInterval(JsVar *func, JsVarFloat interval, JsVar *args, bool isTimeout) {
// NOTE: The 5 sec delay mentioned in the description is handled by jshSleep
JsVar *itemIndex = 0;
if (!jsvIsFunction(func) && !jsvIsString(func)) {
jsExceptionHere(JSET_ERROR, "Function or String not supplied!");
} else {
// Create a new timer
JsVar *timerPtr = jsvNewWithFlags(JSV_OBJECT);
if (interval<TIMER_MIN_INTERVAL) interval=TIMER_MIN_INTERVAL;
JsSysTime intervalInt = jshGetTimeFromMilliseconds(interval);
jsvObjectSetChildAndUnLock(timerPtr, "time", jsvNewFromLongInteger((jshGetSystemTime() - jsiLastIdleTime) + intervalInt));
if (!isTimeout) {
jsvObjectSetChildAndUnLock(timerPtr, "interval", jsvNewFromLongInteger(intervalInt));
}
jsvObjectSetChild(timerPtr, "callback", func); // intentionally no unlock
if (jsvGetArrayLength(args))
jsvObjectSetChild(timerPtr, "args", args); // intentionally no unlock
// Add to array
itemIndex = jsvNewFromInteger(jsiTimerAdd(timerPtr));
jsvUnLock(timerPtr);
jsiTimersChanged(); // mark timers as changed
}
return itemIndex;
}
/*JSON{
"type" : "staticmethod",
"class" : "Promise",
"name" : "all",
"generate" : "jswrap_promise_all",
"params" : [
["promises","JsVar","An array of promises"]
],
"return" : ["JsVar","A new Promise"]
}
Return a new promise that is resolved when all promises in the supplied
array are resolved.
*/
JsVar *jswrap_promise_all(JsVar *arr) {
if (!jsvIsIterable(arr)) {
jsExceptionHere(JSET_TYPEERROR, "Expecting something iterable, got %t", arr);
return 0;
}
JsVar *promise = jspNewObject(0, "Promise");
if (!promise) return 0;
JsVar *resolve = jsvNewNativeFunction((void (*)(void))jswrap_promise_all_resolve, JSWAT_VOID|JSWAT_THIS_ARG|(JSWAT_JSVAR<<JSWAT_BITS));
JsVar *reject = jsvNewNativeFunction((void (*)(void))jswrap_promise_all_reject, JSWAT_VOID|JSWAT_THIS_ARG|(JSWAT_JSVAR<<JSWAT_BITS));
if (resolve && reject) {
jsvObjectSetChild(resolve, JSPARSE_FUNCTION_THIS_NAME, promise);
jsvObjectSetChild(reject, JSPARSE_FUNCTION_THIS_NAME, promise);
int promises = 0;
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
JsVar *p = jsvObjectIteratorGetValue(&it);
jsvUnLock(jswrap_promise_then(p, resolve));
jsvUnLock(jswrap_promise_catch(p, reject));
jsvUnLock(p);
promises++;
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
jsvObjectSetChildAndUnLock(promise, JS_PROMISE_COUNT_NAME, jsvNewFromInteger(promises));
jsvObjectSetChildAndUnLock(promise, JS_PROMISE_RESULT_NAME, jsvNewEmptyArray());
}
jsvUnLock2(resolve, reject);
return promise;
}
/*JSON{
"type" : "staticmethod",
"class" : "Object",
"name" : "getOwnPropertyDescriptor",
"generate" : "jswrap_object_getOwnPropertyDescriptor",
"params" : [
["obj","JsVar","The object"],
["name","JsVar","The name of the property"]
],
"return" : ["JsVar","An object with a description of the property. The values of writable/enumerable/configurable may not be entirely correct due to Espruino's implementation."]
}
Get information on the given property in the object, or undefined
*/
JsVar *jswrap_object_getOwnPropertyDescriptor(JsVar *parent, JsVar *name) {
if (!jswrap_object_hasOwnProperty(parent, name))
return 0;
JsVar *propName = jsvAsArrayIndex(name);
JsVar *varName = jspGetVarNamedField(parent, propName, true);
jsvUnLock(propName);
assert(varName); // we had it! (apparently)
if (!varName) return 0;
JsVar *obj = jsvNewObject();
if (!obj) {
jsvUnLock(varName);
return 0;
}
//jsvTrace(varName, 5);
JsVar *var = jsvSkipName(varName);
bool isBuiltIn = jsvIsNewChild(varName);
JsvIsInternalChecker checkerFunction = jsvGetInternalFunctionCheckerFor(parent);
jsvObjectSetChild(obj, "value", var);
jsvObjectSetChildAndUnLock(obj, "writable", jsvNewFromBool(true));
jsvObjectSetChildAndUnLock(obj, "enumerable", jsvNewFromBool(!checkerFunction || !checkerFunction(varName)));
jsvObjectSetChildAndUnLock(obj, "configurable", jsvNewFromBool(!isBuiltIn));
jsvUnLock2(var, varName);
return obj;
}
/*JSON{
"type" : "method",
"class" : "Pin",
"name" : "getInfo",
"ifndef" : "SAVE_ON_FLASH",
"generate" : "jswrap_pin_getInfo",
"return" : ["JsVar","An object containing information about this pins"]
}
Get information about this pin and its capabilities. Of the form:
```
{
"port" : "A", // the Pin's port on the chip
"num" : 12, // the Pin's number
"in_addr" : 0x..., // (if available) the address of the pin's input address in bit-banded memory (can be used with peek)
"out_addr" : 0x..., // (if available) the address of the pin's output address in bit-banded memory (can be used with poke)
"analog" : { ADCs : [1], channel : 12 }, // If analog input is available
"functions" : {
"TIM1":{type:"CH1, af:0},
"I2C3":{type:"SCL", af:1}
}
}
```
Will return undefined if pin is not valid.
*/
JsVar *jswrap_pin_getInfo(
JsVar *parent //!< The class instance representing the pin.
) {
Pin pin = jshGetPinFromVar(parent);
if (!jshIsPinValid(pin)) return 0;
const JshPinInfo *inf = &pinInfo[pin];
JsVar *obj = jsvNewWithFlags(JSV_OBJECT);
if (!obj) return 0;
char buf[2];
buf[0] = (char)('A'+(inf->port-JSH_PORTA));
buf[1] = 0;
jsvObjectSetChildAndUnLock(obj, "port", jsvNewFromString(buf));
jsvObjectSetChildAndUnLock(obj, "num", jsvNewFromInteger(inf->pin-JSH_PIN0));
#ifdef STM32
volatile uint32_t *addr;
addr = jshGetPinAddress(pin, JSGPAF_INPUT);
if (addr) jsvObjectSetChildAndUnLock(obj, "in_addr", jsvNewFromInteger((JsVarInt)addr));
addr = jshGetPinAddress(pin, JSGPAF_OUTPUT);
if (addr) jsvObjectSetChildAndUnLock(obj, "out_addr", jsvNewFromInteger((JsVarInt)addr));
#endif
// ADC
if (inf->analog) {
JsVar *an = jsvNewWithFlags(JSV_OBJECT);
if (an) {
JsVar *arr = jsvNewWithFlags(JSV_ARRAY);
if (arr) {
int i;
for (i=0;i<ADC_COUNT;i++)
if (inf->analog&(JSH_ANALOG1<<i))
jsvArrayPushAndUnLock(arr, jsvNewFromInteger(1+i));
jsvObjectSetChildAndUnLock(an, "ADCs", arr);
}
jsvObjectSetChildAndUnLock(obj, "channel", jsvNewFromInteger(inf->analog & JSH_MASK_ANALOG_CH));
}
}
JsVar *funcs = jsvNewWithFlags(JSV_OBJECT);
if (funcs) {
int i;
for (i=0;i<JSH_PININFO_FUNCTIONS;i++) {
if (inf->functions[i]) {
JsVar *func = jsvNewWithFlags(JSV_OBJECT);
if (func) {
char buf[16];
jshPinFunctionToString(inf->functions[i], JSPFTS_TYPE, buf, sizeof(buf));
jsvObjectSetChildAndUnLock(func, "type", jsvNewFromString(buf));
jsvObjectSetChildAndUnLock(func, "af", jsvNewFromInteger(inf->functions[i] & JSH_MASK_AF));
jshPinFunctionToString(inf->functions[i], JSPFTS_DEVICE|JSPFTS_DEVICE_NUMBER, buf, sizeof(buf));
jsvObjectSetChildAndUnLock(funcs, buf, func);
}
}
}
jsvObjectSetChildAndUnLock(obj, "functions", funcs);
}
return obj;
}
/*JSON{
"type" : "staticmethod",
"class" : "ESP32",
"name" : "getState",
"generate" : "jswrap_ESP32_getState",
"return" : ["JsVar", "The state of the ESP32"]
}
Returns an object that contains details about the state of the ESP32 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`
*/
JsVar *jswrap_ESP32_getState() {
// Create a new variable and populate it with the properties of the ESP32 that we
// wish to return.
JsVar *esp32State = jsvNewObject();
// system_get_sdk_version() - is deprecated , need to find alternative
jsvObjectSetChildAndUnLock(esp32State, "sdkVersion", jsvNewFromString("1.0 2016-12-03"));
//jsvObjectSetChildAndUnLock(esp32State, "cpuFrequency", jsvNewFromInteger(system_get_cpu_freq()));
jsvObjectSetChildAndUnLock(esp32State, "freeHeap", jsvNewFromInteger(esp_get_free_heap_size()));
return esp32State;
} // End of jswrap_ESP32_getState
JsVar *jswrap_process_memory() {
jsvGarbageCollect();
JsVar *obj = jsvNewWithFlags(JSV_OBJECT);
if (obj) {
unsigned int history = 0;
JsVar *historyVar = jsvObjectGetChild(execInfo.hiddenRoot, JSI_HISTORY_NAME, 0);
if (historyVar) {
history = (unsigned int)jsvCountJsVarsUsed(historyVar); // vars used to store history
jsvUnLock(historyVar);
}
unsigned int usage = jsvGetMemoryUsage() - history;
unsigned int total = jsvGetMemoryTotal();
jsvObjectSetChildAndUnLock(obj, "free", jsvNewFromInteger((JsVarInt)(total-usage)));
jsvObjectSetChildAndUnLock(obj, "usage", jsvNewFromInteger((JsVarInt)usage));
jsvObjectSetChildAndUnLock(obj, "total", jsvNewFromInteger((JsVarInt)total));
jsvObjectSetChildAndUnLock(obj, "history", jsvNewFromInteger((JsVarInt)history));
#ifdef ARM
jsvObjectSetChildAndUnLock(obj, "stackEndAddress", jsvNewFromInteger((JsVarInt)(unsigned int)&LINKER_END_VAR));
jsvObjectSetChildAndUnLock(obj, "flash_start", jsvNewFromInteger((JsVarInt)FLASH_START));
jsvObjectSetChildAndUnLock(obj, "flash_binary_end", jsvNewFromInteger((JsVarInt)(unsigned int)&LINKER_ETEXT_VAR));
jsvObjectSetChildAndUnLock(obj, "flash_code_start", jsvNewFromInteger((JsVarInt)FLASH_SAVED_CODE_START));
jsvObjectSetChildAndUnLock(obj, "flash_length", jsvNewFromInteger((JsVarInt)FLASH_TOTAL));
#endif
}
return obj;
}
JsVar *_jswrap_error_constructor(JsVar *msg, char *type) {
JsVar *d = jspNewObject(0,type);
if (!d) return 0;
if (msg) {
msg = jsvAsString(msg, false);
jsvObjectSetChildAndUnLock(d, "msg", msg);
}
jsvObjectSetChildAndUnLock(d, "type", jsvNewFromString(type));
return d;
}
// Connect this connection/socket
void clientRequestConnect(JsNetwork *net, JsVar *httpClientReqVar) {
// Have we already connected? If so, don't go further
if (jsvGetIntegerAndUnLock(jsvObjectGetChild(httpClientReqVar, HTTP_NAME_SOCKET, 0))>0)
return;
SocketType socketType = socketGetType(httpClientReqVar);
JsVar *options = jsvObjectGetChild(httpClientReqVar, HTTP_NAME_OPTIONS_VAR, false);
unsigned short port = (unsigned short)jsvGetIntegerAndUnLock(jsvObjectGetChild(options, "port", 0));
char hostName[128];
JsVar *hostNameVar = jsvObjectGetChild(options, "host", 0);
if (jsvIsUndefined(hostNameVar))
strncpy(hostName, "localhost", sizeof(hostName));
else
jsvGetString(hostNameVar, hostName, sizeof(hostName));
jsvUnLock(hostNameVar);
uint32_t host_addr = 0;
networkGetHostByName(net, hostName, &host_addr);
if(!host_addr) {
jsError("Unable to locate host\n");
// As this is already in the list of connections, an error will be thrown on idle anyway
jsvObjectSetChildAndUnLock(httpClientReqVar, HTTP_NAME_CLOSENOW, jsvNewFromBool(true));
jsvUnLock(options);
netCheckError(net);
return;
}
NetCreateFlags flags = NCF_NORMAL;
#ifdef USE_TLS
if (socketType & ST_TLS) {
flags |= NCF_TLS;
if (port==0) port = 443;
}
#endif
if (port==0) port = 80;
int sckt = netCreateSocket(net, host_addr, port, flags, options);
if (sckt<0) {
jsError("Unable to create socket\n");
// As this is already in the list of connections, an error will be thrown on idle anyway
jsvObjectSetChildAndUnLock(httpClientReqVar, HTTP_NAME_CLOSENOW, jsvNewFromBool(true));
} else {
jsvObjectSetChildAndUnLock(httpClientReqVar, HTTP_NAME_SOCKET, jsvNewFromInteger(sckt+1));
}
jsvUnLock(options);
netCheckError(net);
}
/*JSON{
"type" : "method",
"class" : "String",
"name" : "match",
"generate" : "jswrap_string_match",
"params" : [
["subStr","JsVar","Substring or RegExp to match"]
],
"return" : ["JsVar","This match array"]
}
Matches `subStr` occurrence in the string.
*/
JsVar *jswrap_string_match(JsVar *parent, JsVar *subStr) {
if (!jsvIsString(parent)) return 0;
if (jsvIsUndefined(subStr)) return 0;
#ifndef SAVE_ON_FLASH
// Use RegExp if one is passed in
if (jsvIsInstanceOf(subStr, "RegExp")) {
jsvObjectSetChildAndUnLock(subStr, "lastIndex", jsvNewFromInteger(0));
JsVar *match;
match = jswrap_regexp_exec(subStr, parent);
if (!jswrap_regexp_hasFlag(subStr,'g')) {
return match;
}
// global
JsVar *array = jsvNewEmptyArray();
if (!array) return 0; // out of memory
while (match && !jsvIsNull(match)) {
// get info about match
JsVar *matchStr = jsvGetArrayItem(match,0);
JsVarInt idx = jsvGetIntegerAndUnLock(jsvObjectGetChild(match,"index",0));
JsVarInt len = (JsVarInt)jsvGetStringLength(matchStr);
int last = idx+len;
jsvArrayPushAndUnLock(array, matchStr);
// search again
jsvUnLock(match);
jsvObjectSetChildAndUnLock(subStr, "lastIndex", jsvNewFromInteger(last));
match = jswrap_regexp_exec(subStr, parent);
}
jsvUnLock(match);
jsvObjectSetChildAndUnLock(subStr, "lastIndex", jsvNewFromInteger(0));
return array;
}
#endif
subStr = jsvAsString(subStr);
int idx = jswrap_string_indexOf(parent, subStr, 0, false);
if (idx>=0) {
JsVar *array = jsvNewEmptyArray();
if (!array) {
jsvUnLock(subStr);
return 0; // out of memory
}
jsvArrayPush(array, subStr);
jsvObjectSetChildAndUnLock(array, "index", jsvNewFromInteger(idx));
jsvObjectSetChildAndUnLock(array, "input", subStr);
return array;
}
jsvUnLock(subStr);
return NULL;
}
static void jswrap_waveform_start(JsVar *waveform, Pin pin, JsVarFloat freq, JsVar *options, bool isWriting) {
bool running = jsvGetBoolAndUnLock(jsvObjectGetChild(waveform, "running", 0));
if (running) {
jsExceptionHere(JSET_ERROR, "Waveform is already running");
return;
}
if (!jshIsPinValid(pin)) {
jsExceptionHere(JSET_ERROR, "Invalid pin");
return;
}
if (!isfinite(freq) || freq<0.001) {
jsExceptionHere(JSET_ERROR, "Frequency must be above 0.001Hz");
return;
}
JsSysTime startTime = jshGetSystemTime();
bool repeat = false;
if (jsvIsObject(options)) {
JsVarFloat t = jsvGetFloatAndUnLock(jsvObjectGetChild(options, "time", 0));
if (isfinite(t) && t>0)
startTime = jshGetTimeFromMilliseconds(t*1000);
repeat = jsvGetBoolAndUnLock(jsvObjectGetChild(options, "repeat", 0));
} else if (!jsvIsUndefined(options)) {
jsExceptionHere(JSET_ERROR, "Expecting options to be undefined or an Object, not %t", options);
}
bool is16Bit = false;
JsVar *buffer = jswrap_waveform_getBuffer(waveform,0, &is16Bit);
JsVar *buffer2 = jswrap_waveform_getBuffer(waveform,1,0);
UtilTimerEventType eventType;
if (is16Bit) {
eventType = isWriting ? UET_WRITE_SHORT : UET_READ_SHORT;
} else {
eventType = isWriting ? UET_WRITE_BYTE : UET_READ_BYTE;
}
// And finally set it up
if (!jstStartSignal(startTime, jshGetTimeFromMilliseconds(1000.0 / freq), pin, buffer, repeat?(buffer2?buffer2:buffer):0, eventType))
jsWarn("Unable to schedule a timer");
jsvUnLock2(buffer,buffer2);
jsvObjectSetChildAndUnLock(waveform, "running", jsvNewFromBool(true));
jsvObjectSetChildAndUnLock(waveform, "freq", jsvNewFromFloat(freq));
// Add to our list of active waveforms
JsVar *waveforms = jsvObjectGetChild(execInfo.hiddenRoot, JSI_WAVEFORM_NAME, JSV_ARRAY);
if (waveforms) {
jsvArrayPush(waveforms, waveform);
jsvUnLock(waveforms);
}
}
/*JSON{
"type" : "idle",
"generate" : "jswrap_waveform_idle",
"ifndef" : "SAVE_ON_FLASH"
}*/
bool jswrap_waveform_idle() {
JsVar *waveforms = jsvObjectGetChild(execInfo.hiddenRoot, JSI_WAVEFORM_NAME, 0);
if (waveforms) {
JsvObjectIterator it;
jsvObjectIteratorNew(&it, waveforms);
while (jsvObjectIteratorHasValue(&it)) {
JsVar *waveform = jsvObjectIteratorGetValue(&it);
bool running = jsvGetBoolAndUnLock(jsvObjectGetChild(waveform, "running", 0));
if (running) {
JsVar *buffer = jswrap_waveform_getBuffer(waveform,0,0);
UtilTimerTask task;
// Search for a timer task
if (!jstGetLastBufferTimerTask(buffer, &task)) {
// if the timer task is now gone...
JsVar *arrayBuffer = jsvObjectGetChild(waveform, "buffer", 0);
jsiQueueObjectCallbacks(waveform, "#onfinish", &arrayBuffer, 1);
jsvUnLock(arrayBuffer);
running = false;
jsvObjectSetChildAndUnLock(waveform, "running", jsvNewFromBool(running));
} else {
// If the timer task is still there...
if (task.data.buffer.nextBuffer &&
task.data.buffer.nextBuffer != task.data.buffer.currentBuffer) {
// if it is a double-buffered task
int currentBuffer = (jsvGetRef(buffer)==task.data.buffer.currentBuffer) ? 0 : 1;
int oldBuffer = jsvGetIntegerAndUnLock(jsvObjectGetChild(waveform, "currentBuffer", JSV_INTEGER));
if (oldBuffer != currentBuffer) {
// buffers have changed - fire off a 'buffer' event with the buffer that needs to be filled
jsvObjectSetChildAndUnLock(waveform, "currentBuffer", jsvNewFromInteger(currentBuffer));
JsVar *arrayBuffer = jsvObjectGetChild(waveform, (currentBuffer==0) ? "buffer" : "buffer2", 0);
jsiQueueObjectCallbacks(waveform, "#onbuffer", &arrayBuffer, 1);
jsvUnLock(arrayBuffer);
}
}
}
jsvUnLock(buffer);
}
jsvUnLock(waveform);
// if not running, remove waveform from this list
if (!running)
jsvObjectIteratorRemoveAndGotoNext(&it, waveforms);
else
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
jsvUnLock(waveforms);
}
return false; // no need to stay awake - an IRQ will wake us
}
// Fire error events on up to two objects if there is an error, returns true if there is an error
// The error events have a code field and a message field.
static bool fireErrorEvent(int error, JsVar *obj1, JsVar *obj2) {
bool hadError = error < 0 && error != SOCKET_ERR_CLOSED;
JsVar *params[1];
if (hadError) {
params[0] = jsvNewObject();
jsvObjectSetChildAndUnLock(params[0], "code", jsvNewFromInteger(error));
jsvObjectSetChildAndUnLock(params[0], "message",
jsvNewFromString(socketErrorString(error)));
if (obj1 != NULL)
jsiQueueObjectCallbacks(obj1, HTTP_NAME_ON_ERROR, params, 1);
if (obj2 != NULL)
jsiQueueObjectCallbacks(obj2, HTTP_NAME_ON_ERROR, params, 1);
jsvUnLock(params[0]);
}
return hadError;
}
/*JSON{
"type" : "method",
"ifndef" : "SAVE_ON_FLASH",
"class" : "RegExp",
"name" : "exec",
"params" : [
["str","JsVar","A string to match on"]
],
"generate" : "jswrap_regexp_exec",
"return" : ["JsVar","A result array, or null"]
}
Test this regex on a string - returns a result array on success, or `null` otherwise.
`/Wo/.exec("Hello World")` will return:
```
[
"Wo",
"index": 6,
"input": "Hello World"
]
```
Or with groups `/W(o)rld/.exec("Hello World")` returns:
```
[
"World",
"o", "index": 6,
"input": "Hello World"
]
```
*/
JsVar *jswrap_regexp_exec(JsVar *parent, JsVar *arg) {
JsVar *str = jsvAsString(arg);
JsVarInt lastIndex = jsvGetIntegerAndUnLock(jsvObjectGetChild(parent, "lastIndex", 0));
JsVar *regex = jsvObjectGetChild(parent, "source", 0);
if (!jsvIsString(regex)) {
jsvUnLock2(str,regex);
return 0;
}
size_t regexLen = jsvGetStringLength(regex);
char *regexPtr = (char *)alloca(regexLen+1);
if (!regexPtr) {
jsvUnLock2(str,regex);
return 0;
}
jsvGetString(regex, regexPtr, regexLen+1);
jsvUnLock(regex);
JsVar *rmatch = match(regexPtr, str, (size_t)lastIndex, jswrap_regexp_hasFlag(parent,'i'));
jsvUnLock(str);
if (!rmatch) {
rmatch = jsvNewWithFlags(JSV_NULL);
lastIndex = 0;
} else {
// if it's global, set lastIndex
if (jswrap_regexp_hasFlag(parent,'g')) {
JsVar *matchStr = jsvGetArrayItem(rmatch,0);
lastIndex = jsvGetIntegerAndUnLock(jsvObjectGetChild(rmatch, "index", 0)) +
(JsVarInt)jsvGetStringLength(matchStr);
jsvUnLock(matchStr);
} else
lastIndex = 0;
}
jsvObjectSetChildAndUnLock(parent, "lastIndex", jsvNewFromInteger(lastIndex));
return rmatch;
}
void serverListen(JsNetwork *net, JsVar *server, int port) {
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVERS, true);
if (!arr) return; // out of memory
jsvObjectSetChildAndUnLock(server, HTTP_NAME_PORT, jsvNewFromInteger(port));
int sckt = netCreateSocket(net, 0/*server*/, (unsigned short)port, NCF_NORMAL, 0 /*options*/);
if (sckt<0) {
jsError("Unable to create socket\n");
jsvObjectSetChildAndUnLock(server, HTTP_NAME_CLOSENOW, jsvNewFromBool(true));
} else {
jsvObjectSetChildAndUnLock(server, HTTP_NAME_SOCKET, jsvNewFromInteger(sckt+1));
// add to list of servers
jsvArrayPush(arr, server);
}
jsvUnLock(arr);
}
/*JSON{
"type" : "constructor",
"class" : "Timer",
"name" : "Timer",
"generate" : "jswrap_Timer_constructor",
"params" : [ ["timerName", "JsVar", "Timer Name"],
["group", "int", "Timer group"],
["index", "int", "Timer index"],
["isrIndex", "int", "isr (0 = Espruino, 1 = test)"] ],
"return" : ["JsVar","A Timer Object"]
}
Creates a Timer Object
*/
JsVar *jswrap_Timer_constructor(JsVar *timerName,int group, int index, int isrIndex){
int idx; char name[20];
JsVar *timer = jspNewObject(0, "Timer");
if(!timer) return 0;
name[jsvGetString(timerName, name, sizeof(name))] = '\0';
idx = timer_Init(name,group,index,isrIndex);
jsvObjectSetChildAndUnLock(timer, "index", jsvNewFromInteger(idx));
return timer;
}
/*JSON{
"type" : "constructor",
"class" : "Queue",
"name" : "Queue",
"generate" : "jswrap_Queue_constructor",
"params" : [ ["queueName", "JsVar", "Name of the queue"] ],
"return" : ["JsVar","A Queue object"]
}
Creates a Queue Object
*/
JsVar *jswrap_Queue_constructor(JsVar *queueName){
int idx; char name[20];
JsVar *queue = jspNewObject(0, "Queue");
if (!queue) return 0;
name[jsvGetString(queueName, name, sizeof(name))] = '\0';
idx = queue_indexByName(name);
jsvObjectSetChildAndUnLock(queue, "index", jsvNewFromInteger(idx));
return queue;
}
void jswrap_promise_all_reject(JsVar *promise, JsVar *data) {
JsVar *arr = jsvObjectGetChild(promise, JS_PROMISE_RESULT_NAME, 0);
if (arr) {
// if not rejected before
jsvUnLock(arr);
jsvObjectSetChildAndUnLock(promise, JS_PROMISE_RESULT_NAME, 0);
_jswrap_promise_queuereject(promise, data);
}
}
/*JSON{
"type" : "constructor",
"class" : "Task",
"name" : "Task",
"generate" : "jswrap_Task_constructor",
"params" : [ ["taskName", "JsVar", "Name of the task"] ],
"return" : ["JsVar","A Task object"]
}
Creates a Task Object
*/
JsVar *jswrap_Task_constructor(JsVar *taskName){
int idx; char name[20];
JsVar *task = jspNewObject(0, "Task");
if (!task) return 0;
name[jsvGetString(taskName, name, sizeof(name))] = '\0';
idx = task_indexByName(name);
jsvObjectSetChildAndUnLock(task, "index", jsvNewFromInteger(idx));
return task;
}
/*JSON{
"type" : "method",
"class" : "WLAN",
"name" : "disconnect",
"generate" : "jswrap_wlan_disconnect"
}
Completely uninitialise and power down the CC3000. After this you'll have to use ```require("CC3000").connect()``` again.
*/
void jswrap_wlan_disconnect(JsVar *wlanObj) {
JsNetwork net;
if (!networkGetFromVar(&net)) return;
jsvObjectSetChildAndUnLock(wlanObj,JS_HIDDEN_CHAR_STR"DIS", jsvNewFromBool(true));
networkState = NETWORKSTATE_OFFLINE; // force offline
//wlan_disconnect();
wlan_stop();
networkFree(&net);
}
/*JSON{
"type" : "staticproperty",
"class" : "process",
"name" : "env",
"generate" : "jswrap_process_env",
"return" : ["JsVar","An object"]
}
Returns an Object containing various pre-defined variables. standard ones are BOARD, VERSION, FLASH, RAM, MODULES.
For example, to get a list of built-in modules, you can use `process.env.MODULES.split(',')`
*/
JsVar *jswrap_process_env() {
JsVar *obj = jsvNewObject();
jsvObjectSetChildAndUnLock(obj, "VERSION", jsvNewFromString(JS_VERSION));
#ifdef GIT_COMMIT
jsvObjectSetChildAndUnLock(obj, "GIT_COMMIT", jsvNewFromString(STRINGIFY(GIT_COMMIT)));
#endif
jsvObjectSetChildAndUnLock(obj, "BOARD", jsvNewFromString(PC_BOARD_ID));
jsvObjectSetChildAndUnLock(obj, "FLASH", jsvNewFromInteger(FLASH_TOTAL));
jsvObjectSetChildAndUnLock(obj, "RAM", jsvNewFromInteger(RAM_TOTAL));
jsvObjectSetChildAndUnLock(obj, "SERIAL", jswrap_interface_getSerial());
jsvObjectSetChildAndUnLock(obj, "CONSOLE", jsvNewFromString(jshGetDeviceString(jsiGetConsoleDevice())));
jsvObjectSetChildAndUnLock(obj, "MODULES", jsvNewFromString(jswGetBuiltInLibraryNames()));
#ifndef SAVE_ON_FLASH
// Pointer to a list of predefined exports - eventually we'll get rid of the array above
jsvObjectSetChildAndUnLock(obj, "EXPTR", jsvNewFromInteger((JsVarInt)(size_t)exportPtrs));
#endif
return obj;
}
// 'end' this connection
void clientRequestEnd(JsNetwork *net, JsVar *httpClientReqVar) {
SocketType socketType = socketGetType(httpClientReqVar);
if ((socketType&ST_TYPE_MASK) == ST_HTTP) {
JsVar *finalData = 0;
if (jsvGetBoolAndUnLock(jsvObjectGetChild(httpClientReqVar, HTTP_NAME_CHUNKED, 0))) {
// If we were asked to send 'chunked' data, we need to finish up
finalData = jsvNewFromString("");
}
// on HTTP, this actually means we connect
// force sendData to be made
clientRequestWrite(net, httpClientReqVar, finalData);
jsvUnLock(finalData);
} else {
// on normal sockets, we actually request close after all data sent
jsvObjectSetChildAndUnLock(httpClientReqVar, HTTP_NAME_CLOSE, jsvNewFromBool(true));
// if we never sent any data, make sure we close 'now'
JsVar *sendData = jsvObjectGetChild(httpClientReqVar, HTTP_NAME_SEND_DATA, 0);
if (!sendData || jsvIsEmptyString(sendData))
jsvObjectSetChildAndUnLock(httpClientReqVar, HTTP_NAME_CLOSENOW, jsvNewFromBool(true));
jsvUnLock(sendData);
}
}
/*JSON{
"type" : "constructor",
"class" : "Waveform",
"name" : "Waveform",
"ifndef" : "SAVE_ON_FLASH",
"generate" : "jswrap_waveform_constructor",
"params" : [
["samples","int32","The number of samples"],
["options","JsVar","Optional options struct `{doubleBuffer:bool, bits : 8/16}` where: `doubleBuffer` is whether to allocate two buffers or not (default false), and bits is the amount of bits to use (default 8)."]
],
"return" : ["JsVar","An Waveform object"]
}
Create a waveform class. This allows high speed input and output of waveforms. It has an internal variable called `buffer` (as well as `buffer2` when double-buffered - see `options` below) which contains the data to input/output.
When double-buffered, a 'buffer' event will be emitted each time a buffer is finished with (the argument is that buffer). When the recording stops, a 'finish' event will be emitted (with the first argument as the buffer).
*/
JsVar *jswrap_waveform_constructor(int samples, JsVar *options) {
if (samples<=0) {
jsExceptionHere(JSET_ERROR, "Samples must be greater than 0");
return 0;
}
bool doubleBuffer = false;
bool use16bit = false;
if (jsvIsObject(options)) {
doubleBuffer = jsvGetBoolAndUnLock(jsvObjectGetChild(options, "doubleBuffer", 0));
int bits = (int)jsvGetIntegerAndUnLock(jsvObjectGetChild(options, "bits", 0));
if (bits!=0 && bits!=8 && bits!=16) {
jsExceptionHere(JSET_ERROR, "Invalid number of bits");
return 0;
} else if (bits==16) use16bit = true;
} else if (!jsvIsUndefined(options)) {
jsExceptionHere(JSET_ERROR, "Expecting options to be undefined or an Object, not %t", options);
}
JsVarDataArrayBufferViewType bufferType = use16bit ? ARRAYBUFFERVIEW_UINT16 : ARRAYBUFFERVIEW_UINT8;
JsVar *arrayBuffer = jsvNewTypedArray(bufferType, samples);
JsVar *arrayBuffer2 = 0;
if (doubleBuffer) arrayBuffer2 = jsvNewTypedArray(bufferType, samples);
JsVar *waveform = jspNewObject(0, "Waveform");
if (!waveform || !arrayBuffer || (doubleBuffer && !arrayBuffer2)) {
jsvUnLock3(waveform,arrayBuffer,arrayBuffer2); // out of memory
return 0;
}
jsvObjectSetChildAndUnLock(waveform, "buffer", arrayBuffer);
if (arrayBuffer2) jsvObjectSetChildAndUnLock(waveform, "buffer2", arrayBuffer2);
return waveform;
}
/*JSON{
"type" : "constructor",
"ifndef" : "SAVE_ON_FLASH",
"class" : "RegExp",
"name" : "RegExp",
"generate" : "jswrap_regexp_constructor",
"params" : [
["regex","JsVar","A regular expression as a string"],
["regex","JsVar","Flags for the regular expression as a string"]
],
"return" : ["JsVar","A RegExp object"],
"return_object" : "RegExp"
}
Creates a RegExp object, for handling Regular Expressions
*/
JsVar *jswrap_regexp_constructor(JsVar *str, JsVar *flags) {
if (!jsvIsString(str)) {
jsExceptionHere(JSET_TYPEERROR, "Expecting String as first argument, got %t", str);
return 0;
}
JsVar *r = jspNewObject(0,"RegExp");
jsvObjectSetChild(r, "source", str);
if (!jsvIsUndefined(flags)) {
if (!jsvIsString(flags))
jsExceptionHere(JSET_TYPEERROR, "Expecting String as first argument, got %t", str);
else
jsvObjectSetChild(r, "flags", flags);
}
jsvObjectSetChildAndUnLock(r, "lastIndex", jsvNewFromInteger(0));
return r;
}
static JsVar *matchfound(JsvStringIterator *txtIt, matchInfo info) {
JsVar *rmatch = jsvNewEmptyArray();
size_t endIndex = jsvStringIteratorGetIndex(txtIt);
JsVar *matchStr = jsvNewFromStringVar(info.sourceStr, info.startIndex, endIndex-info.startIndex);
jsvSetArrayItem(rmatch, 0, matchStr);
jsvUnLock(matchStr);
int i;
for (i=0;i<info.groups;i++) {
matchStr = jsvNewFromStringVar(info.sourceStr, info.groupStart[i], info.groupEnd[i]-info.groupStart[i]);
jsvSetArrayItem(rmatch, i+1, matchStr);
jsvUnLock(matchStr);
}
jsvObjectSetChildAndUnLock(rmatch, "index", jsvNewFromInteger((JsVarInt)info.startIndex));
jsvObjectSetChild(rmatch, "input", info.sourceStr);
return rmatch;
}
static bool allocateJsFile(JsFile* file,FileMode mode, FileType type) {
JsVar *parent = jspNewObject(0, "File");
if (!parent) return false; // low memory
JsVar *data = jsvNewFlatStringOfLength(sizeof(JsFileData));
if (!data) { // out of memory for flat string
jsvUnLock(parent);
return false;
}
file->data = (JsFileData*)jsvGetFlatStringPointer(data);
jsvObjectSetChildAndUnLock(parent, JS_FS_DATA_NAME, data);
file->fileVar = parent;
assert(file->data);
file->data->mode = mode;
file->data->type = type;
file->data->state = FS_NONE;
return true;
}
/*JSON{
"type" : "method",
"class" : "SPI",
"name" : "setup",
"generate" : "jswrap_spi_setup",
"params" : [
["options","JsVar",["An optional structure containing extra information on initialising the SPI port","Please note that baud rate is set to the nearest that can be managed - which may be -+ 50%","```{sck:pin, miso:pin, mosi:pin, baud:integer=100000, mode:integer=0, order:'msb'/'lsb'='msb' }```","If sck,miso and mosi are left out, they will automatically be chosen. However if one or more is specified then the unspecified pins will not be set up.","You can find out which pins to use by looking at [your board's reference page](#boards) and searching for pins with the `SPI` marker.","The SPI ```mode``` is between 0 and 3 - see http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus#Clock_polarity_and_phase","On STM32F1-based parts, you cannot mix AF and non-AF pins (SPI pins are usually grouped on the chip - and you can't mix pins from two groups). Espruino will not warn you about this."]]
]
}
Set up this SPI port as an SPI Master.
*/
void jswrap_spi_setup(
JsVar *parent, //!< The variable that is the class instance of this function.
JsVar *options //!< The options controlling SPI.
) {
//
// Design: The options variable is a JS Object which contains a series of settings. These
// settings are parsed by `jsspiPopulateSPIInfo` to populate a C structure of type
// `JshSPIInfo`.
//
// The options are also hung off the class instance variable in a property symbolically called
// DEVICE_OPTIONS_NAME ("_options").
//
IOEventFlags device = jsiGetDeviceFromClass(parent);
JshSPIInfo inf;
// Debug
// jsiConsolePrintf("jswrap_spi_setup called parent=%v, options=%v\n", parent, options);
jsspiPopulateSPIInfo(&inf, options);
if (DEVICE_IS_SPI(device)) {
jshSPISetup(device, &inf);
#ifdef LINUX
if (jsvIsObject(options)) {
jsvObjectSetChildAndUnLock(parent, "path", jsvObjectGetChild(options, "path", 0));
}
#endif
} else if (device == EV_NONE) {
// software mode - at least configure pins properly
if (inf.pinSCK != PIN_UNDEFINED)
jshPinSetState(inf.pinSCK, JSHPINSTATE_GPIO_OUT);
if (inf.pinMISO != PIN_UNDEFINED)
jshPinSetState(inf.pinMISO, JSHPINSTATE_GPIO_IN);
if (inf.pinMOSI != PIN_UNDEFINED)
jshPinSetState(inf.pinMOSI, JSHPINSTATE_GPIO_OUT);
} else return;
// Set up options, so we can initialise it on startup
if (options)
jsvUnLock(jsvSetNamedChild(parent, options, DEVICE_OPTIONS_NAME));
else
jsvRemoveNamedChild(parent, DEVICE_OPTIONS_NAME);
}
void serverResponseWriteHead(JsVar *httpServerResponseVar, int statusCode, JsVar *headers) {
if (!jsvIsUndefined(headers) && !jsvIsObject(headers)) {
jsError("Headers sent to writeHead should be an object");
return;
}
JsVar *sendData = jsvObjectGetChild(httpServerResponseVar, HTTP_NAME_SEND_DATA, 0);
if (sendData) {
// If sendData!=0 then we were already called
jsError("Headers have already been sent");
jsvUnLock(sendData);
return;
}
sendData = jsvVarPrintf("HTTP/1.0 %d OK\r\nServer: Espruino "JS_VERSION"\r\n", statusCode);
if (headers) httpAppendHeaders(sendData, headers);
// finally add ending newline
jsvAppendString(sendData, "\r\n");
jsvObjectSetChildAndUnLock(httpServerResponseVar, HTTP_NAME_SEND_DATA, sendData);
}
/*JSON{
"type" : "method",
"class" : "WLAN",
"name" : "connect",
"generate" : "jswrap_wlan_connect",
"params" : [
["ap","JsVar","Access point name"],
["key","JsVar","WPA2 key (or undefined for unsecured connection)"],
["callback","JsVar","Function to call back with connection status. It has one argument which is one of 'connect'/'disconnect'/'dhcp'"]
],
"return" : ["bool","True if connection succeeded, false if it didn't."]
}
Connect to a wireless network
*/
bool jswrap_wlan_connect(JsVar *wlanObj, JsVar *vAP, JsVar *vKey, JsVar *callback) {
if (!(jsvIsUndefined(callback) || jsvIsFunction(callback))) {
jsError("Expecting callback Function but got %t", callback);
return 0;
}
JsNetwork net;
if (!networkGetFromVar(&net)) return false;
// if previously completely disconnected, try and reconnect
if (jsvGetBoolAndUnLock(jsvObjectGetChild(wlanObj,JS_HIDDEN_CHAR_STR"DIS",0))) {
cc3000_initialise(wlanObj);
jsvObjectSetChildAndUnLock(wlanObj,JS_HIDDEN_CHAR_STR"DIS", jsvNewFromBool(false));
}
if (jsvIsFunction(callback)) {
jsvObjectSetChild(wlanObj, CC3000_ON_STATE_CHANGE, callback);
}
jsvObjectSetChild(wlanObj,JS_HIDDEN_CHAR_STR"AP", vAP); // no unlock intended
jsvObjectSetChild(wlanObj,JS_HIDDEN_CHAR_STR"KEY", vKey); // no unlock intended
char ap[32];
char key[32];
unsigned long security = WLAN_SEC_UNSEC;
jsvGetString(vAP, ap, sizeof(ap));
if (jsvIsString(vKey)) {
security = WLAN_SEC_WPA2;
jsvGetString(vKey, key, sizeof(key));
}
// might want to set wlan_ioctl_set_connection_policy
bool connected = wlan_connect(security, ap, (long)strlen(ap), NULL, (unsigned char*)key, (long)strlen(key))==0;
networkFree(&net);
// note that we're only online (for networkState) when DHCP succeeds
return connected;
}
/*JSON{
"type" : "method",
"class" : "Serial",
"name" : "setup",
"generate" : "jswrap_serial_setup",
"params" : [
["baudrate","JsVar","The baud rate - the default is 9600"],
["options","JsVar",["An optional structure containing extra information on initialising the serial port.","```{rx:pin,tx:pin,bytesize:8,parity:null/'none'/'o'/'odd'/'e'/'even',stopbits:1,flow:null/undefined/'none'/'xon'}```","You can find out which pins to use by looking at [your board's reference page](#boards) and searching for pins with the `UART`/`USART` markers.","Note that even after changing the RX and TX pins, if you have called setup before then the previous RX and TX pins will still be connected to the Serial port as well - until you set them to something else using digitalWrite"]]
]
}
Setup this Serial port with the given baud rate and options.
If not specified in options, the default pins are used (usually the lowest numbered pins on the lowest port that supports this peripheral)
*/
void jswrap_serial_setup(JsVar *parent, JsVar *baud, JsVar *options) {
IOEventFlags device = jsiGetDeviceFromClass(parent);
if (!DEVICE_IS_USART(device)) return;
JshUSARTInfo inf;
jshUSARTInitInfo(&inf);
if (jsvIsUndefined(options)) {
options = jsvObjectGetChild(parent, DEVICE_OPTIONS_NAME, 0);
} else
jsvLockAgain(options);
JsVar *parity = 0;
JsVar *flow = 0;
jsvConfigObject configs[] = {
{"rx", JSV_PIN, &inf.pinRX},
{"tx", JSV_PIN, &inf.pinTX},
{"ck", JSV_PIN, &inf.pinCK},
{"bytesize", JSV_INTEGER, &inf.bytesize},
{"stopbits", JSV_INTEGER, &inf.stopbits},
{"parity", JSV_OBJECT /* a variable */, &parity},
{"flow", JSV_OBJECT /* a variable */, &flow},
};
if (!jsvIsUndefined(baud)) {
int b = (int)jsvGetInteger(baud);
if (b<=100 || b > 10000000)
jsExceptionHere(JSET_ERROR, "Invalid baud rate specified");
else
inf.baudRate = b;
}
bool ok = true;
if (jsvReadConfigObject(options, configs, sizeof(configs) / sizeof(jsvConfigObject))) {
// sort out parity
inf.parity = 0;
if(jsvIsString(parity)) {
if (jsvIsStringEqual(parity, "o") || jsvIsStringEqual(parity, "odd"))
inf.parity = 1;
else if (jsvIsStringEqual(parity, "e") || jsvIsStringEqual(parity, "even"))
inf.parity = 2;
} else if (jsvIsInt(parity)) {
inf.parity = (unsigned char)jsvGetInteger(parity);
}
if (inf.parity>2) {
jsExceptionHere(JSET_ERROR, "Invalid parity %d", inf.parity);
ok = false;
}
if (ok) {
if (jsvIsUndefined(flow) || jsvIsNull(flow) || jsvIsStringEqual(flow, "none"))
inf.xOnXOff = false;
else if (jsvIsStringEqual(flow, "xon"))
inf.xOnXOff = true;
else {
jsExceptionHere(JSET_ERROR, "Invalid flow control: %q", flow);
ok = false;
}
}
#ifdef LINUX
if (ok && jsvIsObject(options))
jsvObjectSetChildAndUnLock(parent, "path", jsvObjectGetChild(options, "path", 0));
#endif
}
jsvUnLock(parity);
jsvUnLock(flow);
if (!ok) {
jsvUnLock(options);
return;
}
jshUSARTSetup(device, &inf);
// Set baud rate in object, so we can initialise it on startup
jsvObjectSetChildAndUnLock(parent, USART_BAUDRATE_NAME, jsvNewFromInteger(inf.baudRate));
// Do the same for options
if (options)
jsvObjectSetChildAndUnLock(parent, DEVICE_OPTIONS_NAME, options);
else
jsvRemoveNamedChild(parent, DEVICE_OPTIONS_NAME);
}
/*JSON{
"type" : "constructor",
"class" : "OneWire",
"name" : "OneWire",
"generate" : "jswrap_onewire_constructor",
"params" : [
["pin","pin","The pin to implement OneWire on"]
],
"return" : ["JsVar","A OneWire object"]
}
Create a software OneWire implementation on the given pin
*/
JsVar *jswrap_onewire_constructor(Pin pin) {
JsVar *ow = jspNewObject(0, "OneWire");
if (!ow) return 0;
jsvObjectSetChildAndUnLock(ow, "pin", jsvNewFromPin(pin));
return ow;
}
