/*JSON{
"type" : "staticmethod",
"class" : "CC3000",
"name" : "connect",
"generate" : "jswrap_cc3000_connect",
"params" : [
["spi", "JsVar", "Device to use for SPI (or undefined to use the default). SPI should be 1,000,000 baud, and set to 'mode 1'"],
["cs", "pin", "The pin to use for Chip Select"],
["en", "pin", "The pin to use for Enable"],
["irq", "pin", "The pin to use for Interrupts"]
],
"return" : ["JsVar","A WLAN Object"],
"return_object" : "WLAN"
}
Initialise the CC3000 and return a WLAN object
*/
JsVar *jswrap_cc3000_connect(JsVar *spi, Pin cs, Pin en, Pin irq) {
IOEventFlags spiDevice;
if (spi) {
spiDevice = jsiGetDeviceFromClass(spi);
if (!DEVICE_IS_SPI(spiDevice)) {
jsExceptionHere(JSET_ERROR, "Expecting SPI device, got %q", spi);
return 0;
}
} else {
// SPI config
// SPI config
JshSPIInfo inf;
jshSPIInitInfo(&inf);
inf.pinSCK = WLAN_CLK_PIN;
inf.pinMISO = WLAN_MISO_PIN;
inf.pinMOSI = WLAN_MOSI_PIN;
inf.baudRate = 1000000;
inf.spiMode = SPIF_SPI_MODE_1; // Mode 1 CPOL= 0 CPHA= 1
jshSPISetup(WLAN_SPI, &inf);
spiDevice = WLAN_SPI;
}
if (!jshIsPinValid(cs))
cs = WLAN_CS_PIN;
if (!jshIsPinValid(en))
en = WLAN_EN_PIN;
if (!jshIsPinValid(irq))
irq = WLAN_IRQ_PIN;
JsNetwork net;
networkCreate(&net, JSNETWORKTYPE_CC3000);
net.data.device = spiDevice;
net.data.pinCS = cs;
net.data.pinEN = en;
net.data.pinIRQ = irq;
networkSet(&net);
JsVar *wlanObj = jspNewObject(0, "WLAN");
cc3000_initialise(wlanObj);
networkFree(&net);
return wlanObj;
}
/*JSON{ "type":"constructor", "class": "Waveform", "name": "Waveform", "ifndef" : "SAVE_ON_FLASH",
"description" : [ "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)." ],
"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" ]
}*/
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);
}
JsVar *arrayLength = jsvNewFromInteger(samples);
JsVarDataArrayBufferViewType bufferType = use16bit ? ARRAYBUFFERVIEW_UINT16 : ARRAYBUFFERVIEW_UINT8;
JsVar *arrayBuffer = jswrap_typedarray_constructor(bufferType, arrayLength, 0, 0);
JsVar *arrayBuffer2 = 0;
if (doubleBuffer) arrayBuffer2 = jswrap_typedarray_constructor(bufferType, arrayLength, 0, 0);
jsvUnLock(arrayLength);
JsVar *waveform = jspNewObject(0, "Waveform");
if (!waveform || !arrayBuffer || (doubleBuffer && !arrayBuffer2)) {
jsvUnLock(waveform);
jsvUnLock(arrayBuffer); // out of memory
jsvUnLock(arrayBuffer2);
return 0;
}
jsvUnLock(jsvObjectSetChild(waveform, "buffer", arrayBuffer));
if (arrayBuffer2) jsvUnLock(jsvObjectSetChild(waveform, "buffer2", arrayBuffer2));
return waveform;
}
/*JSON{
"type" : "staticmethod",
"class" : "ESP8266",
"name" : "connect",
"generate" : "jswrap_esp8266_connect_device",
"params" : [
["serial","JsVar","The Serial port used for communications with the ESP8266 (must already be setup)"],
["callback","JsVar","Function to call back when connected"]
],
"return" : ["JsVar","An ESP8266 Object"],
"return_object" : "ESP8266"
}
Initialise the WIZnet module and return an Ethernet object
*/
JsVar *jswrap_esp8266_connect_device(JsVar *usart, JsVar *callback) {
IOEventFlags usartDevice;
usartDevice = jsiGetDeviceFromClass(usart);
if (!DEVICE_IS_USART(usartDevice)) {
jsExceptionHere(JSET_ERROR, "Expecting USART device, got %q", usart);
return 0;
}
JsNetwork net;
networkCreate(&net, JSNETWORKTYPE_ESP8266);
net.data.device = usartDevice;
networkSet(&net);
JsVar *wifiObj = 0;
JsVar *cmd = jsvNewFromString("AT+RST\r\n");
esp8266_send(cmd);
jsvUnLock(cmd);
if (esp8266_wait_for("OK", 100, false)) {
if (esp8266_wait_for("ready", 4000, false)) {
networkState = NETWORKSTATE_ONLINE;
wifiObj = jspNewObject(0, "ESPWifi");
} else {
jsExceptionHere(JSET_ERROR, "Module not ready");
}
} else {
jsExceptionHere(JSET_ERROR, "No Acknowledgement");
}
networkFree(&net);
if (callback)
jsiQueueEvents(callback, 0, 0);
return wifiObj;
}
JsVar *httpServerNew(JsVar *callback) {
SOCKET sckt = socket(AF_INET, // Go over TCP/IP
SOCK_STREAM, // This is a stream-oriented socket
IPPROTO_TCP); // Use TCP rather than UDP
if (sckt == INVALID_SOCKET) {
httpError("socket creation failed");
return 0;
}
JsVar *arr = httpGetArray(HTTP_ARRAY_HTTP_SERVERS, true);
if (!arr) return 0; // out of memory
JsVar *server = jspNewObject(jsiGetParser(),0,"httpSrv");
if (!server) {
jsvUnLock(arr);
return 0; // out of memory
}
jsvObjectSetChild(server, HTTP_NAME_ON_CONNECT, callback); // no unlock needed
jsvUnLock(jsvObjectSetChild(server, HTTP_NAME_SOCKET, jsvNewFromInteger(sckt+1)));
#ifndef USE_CC3000
int optval = 1;
if (setsockopt(sckt,SOL_SOCKET,SO_REUSEADDR,(const char *)&optval,sizeof(optval)) < 0)
#else
int optval = SOCK_ON;
if (setsockopt(sckt,SOL_SOCKET,SOCKOPT_ACCEPT_NONBLOCK,(const char *)&optval,sizeof(optval)) < 0)
#endif
jsWarn("setsockopt failed\n");
// add to list of servers
jsvArrayPush(arr, server);
jsvUnLock(arr);
return server;
}
JsVar *jswrap_date_from_milliseconds(JsVarFloat time) {
JsVar *d = jspNewObject(0,"Date");
if (!d) return 0;
jsvUnLock(jsvObjectSetChild(d, "ms", jsvNewFromFloat(time)));
return d;
}
/**
* Callback function that is invoked at the culmination of a scan.
*/
static void scanCB(void *arg, STATUS status) {
/**
* Create a JsVar that is an array of JS objects where each JS object represents a
* retrieved access point set of information. The structure of a record will be:
* o authMode
* o isHidden
* o rssi
* o channel
* o ssid
* When the array has been built, invoke the callback function passing in the array
* of records.
*/
os_printf(">> scanCB\n");
// Create the Empty JS array that will be passed as a parameter to the callback.
JsVar *accessPointArray = jsvNewArray(NULL, 0);
struct bss_info *bssInfo;
bssInfo = (struct bss_info *)arg;
while(bssInfo != NULL) {
// Add a new object to the JS array that will be passed as a parameter to
// the callback. The ESP8266 bssInfo structure contains the following:
// ---
// uint8 bssid[6]
// uint8 ssid[32]
// uint8 channel
// sint8 rssi \96 The received signal strength indication
// AUTH_MODE authmode
// Open = 0
// WEP = 1
// WPA_PSK = 2
// WPA2_PSK = 3
// WPA_WPA2_PSK = 4
// uint8 is_hidden
// sint16 freq_offset
// ---
// Create, populate and add a child ...
JsVar *currentAccessPoint = jspNewObject(NULL, "AccessPoint");
jsvUnLock(jsvObjectSetChild(currentAccessPoint, "rssi", jsvNewFromInteger(bssInfo->rssi)));
jsvUnLock(jsvObjectSetChild(currentAccessPoint, "channel", jsvNewFromInteger(bssInfo->channel)));
jsvUnLock(jsvObjectSetChild(currentAccessPoint, "authMode", jsvNewFromInteger(bssInfo->authmode)));
jsvUnLock(jsvObjectSetChild(currentAccessPoint, "isHidden", jsvNewFromBool(bssInfo->is_hidden)));
// The SSID may **NOT** be NULL terminated ... so handle that.
char ssid[sizeof(bssInfo->ssid) + 1];
os_strncpy((char *)ssid, (char *)bssInfo->ssid, sizeof(bssInfo->ssid));
ssid[sizeof(ssid)-1] = '\0';
jsvUnLock(jsvObjectSetChild(currentAccessPoint, "ssid", jsvNewFromString(ssid)));
// Add the new record to the array
jsvArrayPush(accessPointArray, currentAccessPoint);
os_printf(" - ssid: %s\n", bssInfo->ssid);
bssInfo = STAILQ_NEXT(bssInfo, next);
}
// We have now completed the scan callback, so now we can invoke the JS callback.
JsVar *params[1];
params[0] = accessPointArray;
jsiQueueEvents(NULL, g_jsScanCallback, params, 1);
jsvUnLock(g_jsScanCallback);
os_printf("<< scanCB\n");
}
/*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;
}
bool socketIdle(JsNetwork *net) {
if (networkState != NETWORKSTATE_ONLINE) {
// clear all clients and servers
_socketCloseAllConnections(net);
return false;
}
bool hadSockets = false;
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVERS,false);
if (arr) {
JsvObjectIterator it;
jsvObjectIteratorNew(&it, arr);
while (jsvObjectIteratorHasValue(&it)) {
hadSockets = true;
JsVar *server = jsvObjectIteratorGetValue(&it);
int sckt = (int)jsvGetIntegerAndUnLock(jsvObjectGetChild(server,HTTP_NAME_SOCKET,0))-1; // so -1 if undefined
int theClient = netAccept(net, sckt);
if (theClient >= 0) {
SocketType socketType = socketGetType(server);
if ((socketType&ST_TYPE_MASK) == ST_HTTP) {
JsVar *req = jspNewObject(0, "httpSRq");
JsVar *res = jspNewObject(0, "httpSRs");
if (res && req) { // out of memory?
socketSetType(req, ST_HTTP);
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_SERVER_CONNECTIONS, true);
if (arr) {
jsvArrayPush(arr, req);
jsvUnLock(arr);
}
jsvObjectSetChild(req, HTTP_NAME_RESPONSE_VAR, res);
jsvObjectSetChild(req, HTTP_NAME_SERVER_VAR, server);
jsvObjectSetChildAndUnLock(req, HTTP_NAME_SOCKET, jsvNewFromInteger(theClient+1));
}
jsvUnLock2(req, res);
} else {
// Normal sockets
JsVar *sock = jspNewObject(0, "Socket");
if (sock) { // out of memory?
socketSetType(sock, ST_NORMAL);
JsVar *arr = socketGetArray(HTTP_ARRAY_HTTP_CLIENT_CONNECTIONS, true);
if (arr) {
jsvArrayPush(arr, sock);
jsvUnLock(arr);
}
jsvObjectSetChildAndUnLock(sock, HTTP_NAME_SOCKET, jsvNewFromInteger(theClient+1));
jsiQueueObjectCallbacks(server, HTTP_NAME_ON_CONNECT, &sock, 1);
jsvUnLock(sock);
}
}
}
jsvUnLock(server);
jsvObjectIteratorNext(&it);
}
jsvObjectIteratorFree(&it);
jsvUnLock(arr);
}
if (socketServerConnectionsIdle(net)) hadSockets = true;
if (socketClientConnectionsIdle(net)) hadSockets = true;
netCheckError(net);
return hadSockets;
}
/*JSON{
"type" : "staticmethod",
"class" : "WIZnet",
"name" : "connect",
"generate" : "jswrap_wiznet_connect",
"params" : [
["spi", "JsVar", "Device to use for SPI (or undefined to use the default)"],
["cs", "pin", "The pin to use for Chip Select"]
],
"return" : ["JsVar","An Ethernet Object"],
"return_object" : "Ethernet"
}
Initialise the WIZnet module and return an Ethernet object
*/
JsVar *jswrap_wiznet_connect(JsVar *spi, Pin cs) {
IOEventFlags spiDevice;
if (spi) {
spiDevice = jsiGetDeviceFromClass(spi);
if (!DEVICE_IS_SPI(spiDevice)) {
jsExceptionHere(JSET_ERROR, "Expecting SPI device, got %q", spi);
return 0;
}
} else {
// SPI config
JshSPIInfo inf;
jshSPIInitInfo(&inf);
inf.pinSCK = ETH_CLK_PIN;
inf.pinMISO = ETH_MISO_PIN;
inf.pinMOSI = ETH_MOSI_PIN;
inf.baudRate = 1000000;
inf.spiMode = SPIF_SPI_MODE_0;
jshSPISetup(ETH_SPI, &inf);
spiDevice = ETH_SPI;
}
if (!jshIsPinValid(cs))
cs = ETH_CS_PIN;
JsNetwork net;
networkCreate(&net, JSNETWORKTYPE_W5500);
net.data.device = spiDevice;
net.data.pinCS = cs;
networkSet(&net);
JsVar *ethObj = jspNewObject(0, "Ethernet");
// CS Configuration
jshSetPinStateIsManual(net.data.pinCS, false);
jshPinOutput(net.data.pinCS, 1); // de-assert CS
// Initialise WIZnet functions
reg_wizchip_cs_cbfunc(wizchip_select, wizchip_deselect);
reg_wizchip_spi_cbfunc(wizchip_read, wizchip_write);
/* wizchip initialize*/
uint8_t tmp;
uint8_t memsize[2][8] = { {2,2,2,2,2,2,2,2}, {2,2,2,2,2,2,2,2}};
if(ctlwizchip(CW_INIT_WIZCHIP,(void*)memsize) == -1)
{
jsiConsolePrint("WIZnet Initialize failed.\r\n");
networkFree(&net);
return 0;
}
#if _WIZCHIP_ == 5500
/* PHY link status check - W5100 doesn't have this */
do {
if(ctlwizchip(CW_GET_PHYLINK, (void*)&tmp) == -1) {
jsiConsolePrint("Unknown PHY Link status.\r\n");
networkFree(&net);
return 0;
}
} while (tmp == PHY_LINK_OFF);
#endif
networkFree(&net);
networkState = NETWORKSTATE_ONLINE;
return ethObj;
}
/*JSON{
"type" : "staticmethod",
"class" : "Promise",
"name" : "reject",
"generate" : "jswrap_promise_reject",
"params" : [
["promises","JsVar","Data to pass to the `.catch` handler"]
],
"return" : ["JsVar","A new Promise"]
}
Return a new promise that is already rejected (at idle it'll
call `.catch`)
*/
JsVar *jswrap_promise_reject(JsVar *data) {
JsVar *promise = jspNewObject(0, "Promise");
if (!promise) return 0;
_jswrap_promise_queuereject(promise, data);
return promise;
}
/*JSON{ "type":"staticmethod",
"class" : "CC3000", "name" : "connect",
"generate" : "jswrap_cc3000_connect",
"description" : "Initialise the CC3000 and return a WLAN object",
"params" : [ ],
"return" : ["JsVar", "A WLAN Object"]
}*/
JsVar *jswrap_cc3000_connect() {
JsVar *wlanObj = jspNewObject(0, "WLAN");
cc3000_initialise(wlanObj);
return wlanObj;
}