diff options
Diffstat (limited to 'targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers')
15 files changed, 1525 insertions, 0 deletions
diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/AnalogIn-js.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/AnalogIn-js.h new file mode 100644 index 00000000..89fc8d43 --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/AnalogIn-js.h @@ -0,0 +1,22 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_ANALOGIN_H +#define _JERRYSCRIPT_MBED_DRIVERS_ANALOGIN_H + +#include "jerryscript-mbed-library-registry/wrap_tools.h" + +DECLARE_CLASS_CONSTRUCTOR(AnalogIn); + +#endif // _JERRYSCRIPT_MBED_DRIVERS_ANALOGIN_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/DigitalOut-js.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/DigitalOut-js.h new file mode 100644 index 00000000..1c819fde --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/DigitalOut-js.h @@ -0,0 +1,22 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_DIGITALOUT_H +#define _JERRYSCRIPT_MBED_DRIVERS_DIGITALOUT_H + +#include "jerryscript-mbed-library-registry/wrap_tools.h" + +DECLARE_CLASS_CONSTRUCTOR(DigitalOut); + +#endif // _JERRYSCRIPT_MBED_DRIVERS_DIGITALOUT_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/I2C-js.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/I2C-js.h new file mode 100644 index 00000000..984dcc08 --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/I2C-js.h @@ -0,0 +1,22 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_I2C_H +#define _JERRYSCRIPT_MBED_DRIVERS_I2C_H + +#include "jerryscript-mbed-library-registry/wrap_tools.h" + +DECLARE_CLASS_CONSTRUCTOR(I2C); + +#endif // _JERRYSCRIPT_MBED_DRIVERS_I2C_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/InterruptIn-js.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/InterruptIn-js.h new file mode 100644 index 00000000..a41cca0f --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/InterruptIn-js.h @@ -0,0 +1,22 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_INTERRUPTIN_H +#define _JERRYSCRIPT_MBED_DRIVERS_INTERRUPTIN_H + +#include "jerryscript-mbed-library-registry/wrap_tools.h" + +DECLARE_CLASS_CONSTRUCTOR(InterruptIn); + +#endif // _JERRYSCRIPT_MBED_DRIVERS_INTERRUPTIN_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/PwmOut-js.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/PwmOut-js.h new file mode 100644 index 00000000..91ef751f --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/PwmOut-js.h @@ -0,0 +1,22 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_PWMOUT_H +#define _JERRYSCRIPT_MBED_DRIVERS_PWMOUT_H + +#include "jerryscript-mbed-library-registry/wrap_tools.h" + +DECLARE_CLASS_CONSTRUCTOR(PwmOut); + +#endif // _JERRYSCRIPT_MBED_DRIVERS_PWMOUT_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/lib_drivers.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/lib_drivers.h new file mode 100644 index 00000000..7ec44d0c --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/lib_drivers.h @@ -0,0 +1,42 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_LIB_DRIVERS_H +#define _JERRYSCRIPT_MBED_DRIVERS_LIB_DRIVERS_H + +#include "jerryscript-ext/handler.h" +#include "jerryscript-mbed-drivers/InterruptIn-js.h" +#include "jerryscript-mbed-drivers/DigitalOut-js.h" +#include "jerryscript-mbed-drivers/setInterval-js.h" +#include "jerryscript-mbed-drivers/setTimeout-js.h" +#include "jerryscript-mbed-drivers/I2C-js.h" +#include "jerryscript-mbed-drivers/AnalogIn-js.h" +#include "jerryscript-mbed-drivers/PwmOut-js.h" + +DECLARE_JS_WRAPPER_REGISTRATION (base) { + REGISTER_GLOBAL_FUNCTION_WITH_HANDLER(assert, jerryx_handler_assert); + REGISTER_GLOBAL_FUNCTION_WITH_HANDLER(gc, jerryx_handler_gc); + REGISTER_GLOBAL_FUNCTION_WITH_HANDLER(print, jerryx_handler_print); + REGISTER_GLOBAL_FUNCTION(setInterval); + REGISTER_GLOBAL_FUNCTION(setTimeout); + REGISTER_GLOBAL_FUNCTION(clearInterval); + REGISTER_GLOBAL_FUNCTION(clearTimeout); + REGISTER_CLASS_CONSTRUCTOR(DigitalOut); + REGISTER_CLASS_CONSTRUCTOR(I2C); + REGISTER_CLASS_CONSTRUCTOR(InterruptIn); + REGISTER_CLASS_CONSTRUCTOR(AnalogIn); + REGISTER_CLASS_CONSTRUCTOR(PwmOut); +} + +#endif // _JERRYSCRIPT_MBED_DRIVERS_LIB_DRIVERS_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/setInterval-js.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/setInterval-js.h new file mode 100644 index 00000000..25016279 --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/setInterval-js.h @@ -0,0 +1,23 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_SET_INTERVAL_H +#define _JERRYSCRIPT_MBED_DRIVERS_SET_INTERVAL_H + +#include "jerryscript-mbed-library-registry/wrap_tools.h" + +DECLARE_GLOBAL_FUNCTION(setInterval); +DECLARE_GLOBAL_FUNCTION(clearInterval); + +#endif // _JERRYSCRIPT_MBED_DRIVERS_SET_INTERVAL_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/setTimeout-js.h b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/setTimeout-js.h new file mode 100644 index 00000000..13174f7f --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/setTimeout-js.h @@ -0,0 +1,23 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef _JERRYSCRIPT_MBED_DRIVERS_SET_TIMEOUT_H +#define _JERRYSCRIPT_MBED_DRIVERS_SET_TIMEOUT_H + +#include "jerryscript-mbed-library-registry/wrap_tools.h" + +DECLARE_GLOBAL_FUNCTION(setTimeout); +DECLARE_GLOBAL_FUNCTION(clearTimeout); + +#endif // _JERRYSCRIPT_MBED_DRIVERS_SET_TIMEOUT_H diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/AnalogIn-js.cpp b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/AnalogIn-js.cpp new file mode 100644 index 00000000..4c3499b8 --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/AnalogIn-js.cpp @@ -0,0 +1,114 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "jerryscript-mbed-library-registry/wrap_tools.h" +#include "jerryscript-mbed-util/logging.h" +#include "mbed.h" + +/** + * AnalogIn#destructor + * + * Called if/when the AnalogIn is GC'ed. + */ +void +NAME_FOR_CLASS_NATIVE_DESTRUCTOR (AnalogIn) (void* void_ptr, jerry_object_native_info_t* info_p) +{ + (void) info_p; + delete static_cast<AnalogIn*> (void_ptr); +} + +/** + * Type infomation of the native AnalogIn pointer + * + * Set AnalogIn#destructor as the free callback. + */ +static const jerry_object_native_info_t native_obj_type_info = { .free_cb = + NAME_FOR_CLASS_NATIVE_DESTRUCTOR (AnalogIn) }; + +/** + * AnalogIn#read (native JavaScript method) + * + * Read the input voltage, represented as a float in the range [0.0, 1.0] + * + * @returns A floating-point value representing the current input voltage, measured as a percentage + */ +DECLARE_CLASS_FUNCTION (AnalogIn, read) +{ + CHECK_ARGUMENT_COUNT (AnalogIn, read, (args_count == 0)); + + // Extract native AnalogIn pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native AnalogIn pointer"); + } + + AnalogIn* native_ptr = static_cast<AnalogIn*> (void_ptr); + + float result = native_ptr->read (); + return jerry_number (result); +} + +/** + * AnalogIn#read_u16 (native JavaScript method) + * + * Read the input voltage, represented as an unsigned short in the range [0x0, 0xFFFF] + * + * @returns 16-bit unsigned short representing the current input voltage, normalised to a 16-bit value + */ +DECLARE_CLASS_FUNCTION (AnalogIn, read_u16) +{ + CHECK_ARGUMENT_COUNT (AnalogIn, read_u16, (args_count == 0)); + + // Extract native AnalogIn pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native AnalogIn pointer"); + } + + AnalogIn* native_ptr = static_cast<AnalogIn*> (void_ptr); + + uint16_t result = native_ptr->read_u16 (); + return jerry_number (result); +} + +/** + * AnalogIn (native JavaScript constructor) + * + * @param pin_name mbed pin to connect the AnalogIn to. + * @returns a JavaScript object representing a AnalogIn. + */ +DECLARE_CLASS_CONSTRUCTOR (AnalogIn) +{ + CHECK_ARGUMENT_COUNT (AnalogIn, __constructor, args_count == 1); + CHECK_ARGUMENT_TYPE_ALWAYS (AnalogIn, __constructor, 0, number); + + PinName pin_name = PinName (jerry_value_as_number (args[0])); + + // create native object + AnalogIn* native_ptr = new AnalogIn (pin_name); + + // create the jerryscript object + jerry_value_t js_object = jerry_object (); + jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr); + + // attach methods + ATTACH_CLASS_FUNCTION (js_object, AnalogIn, read); + ATTACH_CLASS_FUNCTION (js_object, AnalogIn, read_u16); + + return js_object; +} diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/DigitalOut-js.cpp b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/DigitalOut-js.cpp new file mode 100644 index 00000000..1ab03707 --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/DigitalOut-js.cpp @@ -0,0 +1,158 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "jerryscript-mbed-library-registry/wrap_tools.h" +#include "jerryscript-mbed-util/logging.h" +#include "mbed.h" + +/** + * DigitalOut#destructor + * + * Called if/when the DigitalOut is GC'ed. + */ +void +NAME_FOR_CLASS_NATIVE_DESTRUCTOR (DigitalOut) (void* void_ptr, jerry_object_native_info_t* info_p) +{ + (void) info_p; + delete static_cast<DigitalOut*> (void_ptr); +} + +/** + * Type infomation of the native DigitalOut pointer + * + * Set DigitalOut#destructor as the free callback. + */ +static const jerry_object_native_info_t native_obj_type_info = { .free_cb = + NAME_FOR_CLASS_NATIVE_DESTRUCTOR (DigitalOut) }; + +/** + * DigitalOut#write (native JavaScript method) + * + * Writes a binary value to a DigitalOut. + * + * @param value 1 or 0, specifying whether the output pin is high or low, + * respectively + * @returns undefined, or an error if invalid arguments are provided. + */ +DECLARE_CLASS_FUNCTION (DigitalOut, write) +{ + CHECK_ARGUMENT_COUNT (DigitalOut, write, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (DigitalOut, write, 0, number); + + // Extract native DigitalOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native DigitalOut pointer"); + } + + DigitalOut* native_ptr = static_cast<DigitalOut*> (void_ptr); + + int arg0 = jerry_value_as_number (args[0]); + native_ptr->write (arg0); + + return jerry_undefined (); +} + +/** + * DigitalOut#read (native JavaScript method) + * + * Reads the current status of a DigitalOut + * + * @returns 1 if the pin is currently high, or 0 if the pin is currently low. + */ +DECLARE_CLASS_FUNCTION (DigitalOut, read) +{ + CHECK_ARGUMENT_COUNT (DigitalOut, read, (args_count == 0)); + + // Extract native DigitalOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native DigitalOut pointer"); + } + + DigitalOut* native_ptr = static_cast<DigitalOut*> (void_ptr); + + int result = native_ptr->read (); + return jerry_number (result); +} + +/** + * DigitalOut#is_connected (native JavaScript method) + * + * @returns 0 if the DigitalOut is set to NC, or 1 if it is connected to an + * actual pin + */ +DECLARE_CLASS_FUNCTION (DigitalOut, is_connected) +{ + CHECK_ARGUMENT_COUNT (DigitalOut, is_connected, (args_count == 0)); + + // Extract native DigitalOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native DigitalOut pointer"); + } + + DigitalOut* native_ptr = static_cast<DigitalOut*> (void_ptr); + + int result = native_ptr->is_connected (); + return jerry_number (result); +} + +/** + * DigitalOut (native JavaScript constructor) + * + * @param pin_name mbed pin to connect the DigitalOut to. + * @param value (optional) Initial value of the DigitalOut. + * @returns a JavaScript object representing a DigitalOut. + */ +DECLARE_CLASS_CONSTRUCTOR (DigitalOut) +{ + CHECK_ARGUMENT_COUNT (DigitalOut, __constructor, (args_count == 1 || args_count == 2)); + CHECK_ARGUMENT_TYPE_ALWAYS (DigitalOut, __constructor, 0, number); + CHECK_ARGUMENT_TYPE_ON_CONDITION (DigitalOut, __constructor, 1, number, (args_count == 2)); + + DigitalOut* native_ptr; + + // Call correct overload of DigitalOut::DigitalOut depending on the + // arguments passed. + PinName pin_name = PinName (jerry_value_as_number (args[0])); + + switch (args_count) + { + case 1: + native_ptr = new DigitalOut (pin_name); + break; + case 2: + int value = static_cast<int> (jerry_value_as_number (args[1])); + native_ptr = new DigitalOut (pin_name, value); + break; + } + + // create the jerryscript object + jerry_value_t js_object = jerry_object (); + jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr); + + // attach methods + ATTACH_CLASS_FUNCTION (js_object, DigitalOut, write); + ATTACH_CLASS_FUNCTION (js_object, DigitalOut, read); + ATTACH_CLASS_FUNCTION (js_object, DigitalOut, is_connected); + + return js_object; +} diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/I2C-js.cpp b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/I2C-js.cpp new file mode 100644 index 00000000..90cbc83c --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/I2C-js.cpp @@ -0,0 +1,327 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "jerryscript-mbed-drivers/I2C-js.h" + +#include "jerryscript-mbed-library-registry/wrap_tools.h" +#include "jerryscript-mbed-util/logging.h" +#include "mbed.h" + +/** + * I2C#destructor + * + * Called if/when the I2C object is GC'ed. + */ +void +NAME_FOR_CLASS_NATIVE_DESTRUCTOR (I2C) (void *void_ptr, jerry_object_native_info_t *info_p) +{ + (void) info_p; + delete static_cast<I2C *> (void_ptr); +} + +/** + * Type infomation of the native I2C pointer + * + * Set I2C#destructor as the free callback. + */ +static const jerry_object_native_info_t native_obj_type_info = { .free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR (I2C) }; + +/** + * I2C#frequency (native JavaScript method) + * + * Set the frequency of the I2C bus. + * + * @param frequency New I2C Frequency + */ +DECLARE_CLASS_FUNCTION (I2C, frequency) +{ + CHECK_ARGUMENT_COUNT (I2C, frequency, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, frequency, 0, number); + + // Unwrap native I2C object + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer"); + } + + I2C *native_ptr = static_cast<I2C *> (void_ptr); + + int hz = jerry_value_as_number (args[0]); + native_ptr->frequency (hz); + + return jerry_undefined (); +} + +/** + * I2C#read (native JavaScript method) + * + * Read data from the I2C bus. + * + * @overload I2C#read(int) + * Read a single byte from the I2C bus + * + * @param ack indicates if the byte is to be acknowledged (1 => acknowledge) + * + * @returns array: Data read from the I2C bus + * + * @overload I2C#read(int, array, int) + * Read a series of bytes from the I2C bus + * + * @param address I2C address to read from + * @param data Array to read into + * @param length Length of data to read + * + * @returns array: Data read from the I2C bus + */ +DECLARE_CLASS_FUNCTION (I2C, read) +{ + CHECK_ARGUMENT_COUNT (I2C, read, (args_count == 1 || args_count == 3 || args_count == 4)); + + if (args_count == 1) + { + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 0, number); + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer"); + } + + I2C *native_ptr = static_cast<I2C *> (void_ptr); + + int data = jerry_value_as_number (args[0]); + int result = native_ptr->read (data); + + return jerry_number (result); + } + else + { + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 0, number); + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 1, array); + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 2, number); + + CHECK_ARGUMENT_TYPE_ON_CONDITION (I2C, read, 3, boolean, (args_count == 4)); + + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer"); + } + + I2C *native_ptr = static_cast<I2C *> (void_ptr); + + const uint32_t data_len = jerry_array_length (args[1]); + + int address = jerry_value_as_number (args[0]); + int length = jerry_value_as_number (args[2]); + + char *data = new char[data_len]; + + bool repeated = false; + if (args_count == 4) + { + repeated = jerry_value_is_true (args[3]); + } + + int result = native_ptr->read (address, data, length, repeated); + + jerry_value_t out_array = jerry_array (data_len); + + for (uint32_t i = 0; i < data_len; i++) + { + jerry_value_t val = jerry_number (double (data[i])); + jerry_value_free (jerry_object_set_index (out_array, i, val)); + jerry_value_free (val); + } + + delete[] data; + + if (result == 0) + { + // ACK + return out_array; + } + else + { + // NACK + const char *error_msg = "NACK received from I2C bus"; + + jerry_value_free (out_array); + return jerry_throw_sz (JERRY_ERROR_COMMON, error_msg); + } + } +} + +/** + * I2C#write (native JavaScript method) + * + * @overload I2C#write(int) + * Write a single byte to the I2C bus + * + * @param data Data byte to write to the I2C bus + * + * @returns 1 on success, 0 on failure + * + * @overload I2C#write(int, array, int, bool) + * Write an array of data to a certain address on the I2C bus + * + * @param address 8-bit I2C slave address + * @param data Array of bytes to send + * @param length Length of data to write + * @param repeated (optional) If true, do not send stop at end. + * + * @returns 0 on success, non-0 on failure + */ +DECLARE_CLASS_FUNCTION (I2C, write) +{ + CHECK_ARGUMENT_COUNT (I2C, write, (args_count == 1 || args_count == 3 || args_count == 4)); + + if (args_count == 1) + { + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 0, number); + + // Extract native I2C object + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer"); + } + + I2C *native_ptr = static_cast<I2C *> (void_ptr); + + // Unwrap arguments + int data = jerry_value_as_number (args[0]); + + int result = native_ptr->write (data); + return jerry_number (result); + } + else + { + // 3 or 4 + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 0, number); + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 1, array); + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 2, number); + CHECK_ARGUMENT_TYPE_ON_CONDITION (I2C, write, 3, boolean, (args_count == 4)); + + // Extract native I2C object + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr != NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer"); + } + + I2C *native_ptr = static_cast<I2C *> (void_ptr); + + // Unwrap arguments + int address = jerry_value_as_number (args[0]); + const uint32_t data_len = jerry_array_length (args[1]); + int length = jerry_value_as_number (args[2]); + bool repeated = args_count == 4 && jerry_value_is_true (args[3]); + + // Construct data byte array + char *data = new char[data_len]; + for (uint32_t i = 0; i < data_len; i++) + { + data[i] = jerry_value_as_number (jerry_object_get_index (args[1], i)); + } + + int result = native_ptr->write (address, data, length, repeated); + + // free dynamically allocated resources + delete[] data; + + return jerry_number (result); + } +} + +/** + * I2C#start (native JavaScript method) + * + * Creates a start condition on the I2C bus. + */ +DECLARE_CLASS_FUNCTION (I2C, start) +{ + CHECK_ARGUMENT_COUNT (I2C, start, (args_count == 0)); + + // Extract native I2C object + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer"); + } + + I2C *native_ptr = static_cast<I2C *> (void_ptr); + + native_ptr->start (); + return jerry_undefined (); +} + +/** + * I2C#stop (native JavaScript method) + * + * Creates a stop condition on the I2C bus. + */ +DECLARE_CLASS_FUNCTION (I2C, stop) +{ + CHECK_ARGUMENT_COUNT (I2C, stop, (args_count == 0)); + + // Extract native I2C object + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer"); + } + + I2C *native_ptr = static_cast<I2C *> (void_ptr); + + native_ptr->stop (); + return jerry_undefined (); +} + +/** + * I2C (native JavaScript constructor) + * + * @param sda mbed pin for I2C data + * @param scl mbed pin for I2C clock + * @returns a JavaScript object representing the I2C bus. + */ +DECLARE_CLASS_CONSTRUCTOR (I2C) +{ + CHECK_ARGUMENT_COUNT (I2C, __constructor, (args_count == 2)); + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, __constructor, 0, number); + CHECK_ARGUMENT_TYPE_ALWAYS (I2C, __constructor, 1, number); + + int sda = jerry_value_as_number (args[0]); + int scl = jerry_value_as_number (args[1]); + + I2C *native_ptr = new I2C ((PinName) sda, (PinName) scl); + + jerry_value_t js_object = jerry_object (); + jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr); + + ATTACH_CLASS_FUNCTION (js_object, I2C, frequency); + ATTACH_CLASS_FUNCTION (js_object, I2C, read); + ATTACH_CLASS_FUNCTION (js_object, I2C, write); + ATTACH_CLASS_FUNCTION (js_object, I2C, start); + ATTACH_CLASS_FUNCTION (js_object, I2C, stop); + + return js_object; +} diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/InterruptIn-js.cpp b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/InterruptIn-js.cpp new file mode 100644 index 00000000..2d7c1b2e --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/InterruptIn-js.cpp @@ -0,0 +1,272 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "jerryscript-mbed-event-loop/EventLoop.h" +#include "jerryscript-mbed-library-registry/wrap_tools.h" +#include "jerryscript-mbed-util/logging.h" +#include "mbed.h" + +/** + * InterruptIn#destructor + * + * Called if/when the InterruptIn object is GC'ed. + */ +void +NAME_FOR_CLASS_NATIVE_DESTRUCTOR (InterruptIn) (void *void_ptr, jerry_object_native_info_t *info_p) +{ + (void) info_p; + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + native_ptr->rise (0); + native_ptr->fall (0); + delete native_ptr; +} + +/** + * Type infomation of the native InterruptIn pointer + * + * Set InterruptIn#destructor as the free callback. + */ +static const jerry_object_native_info_t native_obj_type_info = { .free_cb = + NAME_FOR_CLASS_NATIVE_DESTRUCTOR (InterruptIn) }; + +/** + * InterruptIn#rise (native JavaScript method) + * + * Register a rise callback for an InterruptIn + * + * @param cb Callback function, or null to detach previously attached callback. + */ +DECLARE_CLASS_FUNCTION (InterruptIn, rise) +{ + CHECK_ARGUMENT_COUNT (InterruptIn, rise, (args_count == 1)); + + // Detach the rise callback when InterruptIn::rise(null) is called + if (jerry_value_is_null (args[0])) + { + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer"); + } + + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + jerry_value_t property_name = jerry_string_sz ("cb_rise"); + jerry_value_t cb_func = jerry_object_get (call_info_p->this_value, property_name); + jerry_value_free (property_name); + + // Only drop the callback if it exists + if (jerry_value_is_function (cb_func)) + { + // Ensure that the EventLoop frees memory used by the callback. + mbed::js::EventLoop::getInstance ().dropCallback (cb_func); + } + jerry_value_free (cb_func); + + native_ptr->rise (0); + + return jerry_undefined (); + } + + // Assuming we actually have a callback now... + CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, rise, 0, function); + + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer"); + } + + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + jerry_value_t f = args[0]; + + // Pass the function to EventLoop. + mbed::Callback<void ()> cb = mbed::js::EventLoop::getInstance ().wrapFunction (f); + native_ptr->rise (cb); + + // Keep track of our callback internally. + jerry_value_t property_name = jerry_string_sz ("cb_rise"); + jerry_value_free (jerry_object_set (call_info_p->this_value, property_name, f)); + jerry_value_free (property_name); + + return jerry_undefined (); +} + +/** + * InterruptIn#fall (native JavaScript method) + * + * Register a fall callback for an InterruptIn + * + * @param cb Callback function, or null to detach previously attached callback. + */ +DECLARE_CLASS_FUNCTION (InterruptIn, fall) +{ + CHECK_ARGUMENT_COUNT (InterruptIn, fall, (args_count == 1)); + + // Detach the fall callback when InterruptIn::fall(null) is called + if (jerry_value_is_null (args[0])) + { + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer"); + } + + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + jerry_value_t property_name = jerry_string_sz ("cb_fall"); + jerry_value_t cb_func = jerry_object_get (call_info_p->this_value, property_name); + jerry_value_free (property_name); + + // Only drop the callback if it exists + if (jerry_value_is_function (cb_func)) + { + // Ensure that the EventLoop frees memory used by the callback. + mbed::js::EventLoop::getInstance ().dropCallback (cb_func); + } + jerry_value_free (cb_func); + + native_ptr->fall (0); + + return jerry_undefined (); + } + + // Assuming we actually have a callback now... + CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, fall, 0, function); + + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer"); + } + + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + jerry_value_t f = args[0]; + + // Pass the function to EventLoop. + mbed::Callback<void ()> cb = mbed::js::EventLoop::getInstance ().wrapFunction (f); + native_ptr->fall (cb); + + // Keep track of our callback internally. + jerry_value_t property_name = jerry_string_sz ("cb_fall"); + jerry_value_free (jerry_object_set (call_info_p->this_value, property_name, f)); + jerry_value_free (property_name); + + return jerry_undefined (); +} + +/** + * InterruptIn#mode (native JavaScript method) + * + * Set the mode of the InterruptIn pin. + * + * @param mode PullUp, PullDown, PullNone + */ +DECLARE_CLASS_FUNCTION (InterruptIn, mode) +{ + CHECK_ARGUMENT_COUNT (InterruptIn, mode, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, mode, 0, number); + + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer"); + } + + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + int pull = jerry_value_as_number (args[0]); + native_ptr->mode ((PinMode) pull); + + return jerry_undefined (); +} + +/** + * InterruptIn#disable_irq (native JavaScript method) + * + * Disable IRQ. See InterruptIn.h in mbed-os sources for more details. + */ +DECLARE_CLASS_FUNCTION (InterruptIn, disable_irq) +{ + CHECK_ARGUMENT_COUNT (InterruptIn, disable_irq, (args_count == 0)); + + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer"); + } + + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + native_ptr->disable_irq (); + return jerry_undefined (); +} + +/** + * InterruptIn#enable_irq (native JavaScript method) + * + * Enable IRQ. See InterruptIn.h in mbed-os sources for more details. + */ +DECLARE_CLASS_FUNCTION (InterruptIn, enable_irq) +{ + CHECK_ARGUMENT_COUNT (InterruptIn, enable_irq, (args_count == 0)); + + void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer"); + } + + InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr); + + native_ptr->enable_irq (); + return jerry_undefined (); +} + +/** + * InterruptIn (native JavaScript constructor) + * + * @param pin PinName + * + * @returns JavaScript object wrapping InterruptIn native object + */ +DECLARE_CLASS_CONSTRUCTOR (InterruptIn) +{ + CHECK_ARGUMENT_COUNT (InterruptIn, __constructor, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, __constructor, 0, number); + int pin = jerry_value_as_number (args[0]); + + InterruptIn *native_ptr = new InterruptIn ((PinName) pin); + jerry_value_t js_object = jerry_object (); + + jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr); + + ATTACH_CLASS_FUNCTION (js_object, InterruptIn, rise); + ATTACH_CLASS_FUNCTION (js_object, InterruptIn, fall); + ATTACH_CLASS_FUNCTION (js_object, InterruptIn, mode); + ATTACH_CLASS_FUNCTION (js_object, InterruptIn, enable_irq); + ATTACH_CLASS_FUNCTION (js_object, InterruptIn, disable_irq); + + return js_object; +} diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/PwmOut-js.cpp b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/PwmOut-js.cpp new file mode 100644 index 00000000..de332c5b --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/PwmOut-js.cpp @@ -0,0 +1,292 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "jerryscript-mbed-library-registry/wrap_tools.h" +#include "jerryscript-mbed-util/logging.h" +#include "mbed.h" + +/** + * PwmOut#destructor + * + * Called if/when the PwmOut is GC'ed. + */ +void +NAME_FOR_CLASS_NATIVE_DESTRUCTOR (PwmOut) (void* void_ptr, jerry_object_native_info_t* info_p) +{ + (void) info_p; + delete static_cast<PwmOut*> (void_ptr); +} + +/** + * Type infomation of the native PwmOut pointer + * + * Set PwmOut#destructor as the free callback. + */ +static const jerry_object_native_info_t native_obj_type_info = { .free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR (PwmOut) }; + +/** + * PwmOut#write (native JavaScript method) + * + * Set the ouput duty-cycle, specified as a percentage (float) + * + * @param value A floating-point value representing the output duty-cycle, + * specified as a percentage. The value should lie between + * 0.0 (representing on 0%) and 1.0 (representing on 100%). + * Values outside this range will be saturated to 0.0f or 1.0f + * @returns undefined + */ +DECLARE_CLASS_FUNCTION (PwmOut, write) +{ + CHECK_ARGUMENT_COUNT (PwmOut, write, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, write, 0, number); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + double arg0 = jerry_value_as_number (args[0]); + native_ptr->write (static_cast<float> (arg0)); + + return jerry_undefined (); +} + +/** + * PwmOut#read (native JavaScript method) + * + * Return the current output duty-cycle setting, measured as a percentage (float) + * + * @returns + * A floating-point value representing the current duty-cycle being output on the pin, + * measured as a percentage. The returned value will lie between + * 0.0 (representing on 0%) and 1.0 (representing on 100%). + * + * @note + * This value may not match exactly the value set by a previous <write>. + */ +DECLARE_CLASS_FUNCTION (PwmOut, read) +{ + CHECK_ARGUMENT_COUNT (PwmOut, read, (args_count == 0)); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + float result = native_ptr->read (); + return jerry_number (result); +} + +/** + * PwmOut#period (native JavaScript method) + * + * Set the PWM period, specified in seconds (float), keeping the duty cycle the same. + * + * @note + * The resolution is currently in microseconds; periods smaller than this + * will be set to zero. + */ +DECLARE_CLASS_FUNCTION (PwmOut, period) +{ + CHECK_ARGUMENT_COUNT (PwmOut, period, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, period, 0, number); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + double arg0 = jerry_value_as_number (args[0]); + native_ptr->period (static_cast<float> (arg0)); + + return jerry_undefined (); +} + +/** + * PwmOut#period_ms (native JavaScript method) + * + * Set the PWM period, specified in milli-seconds (int), keeping the duty cycle the same. + */ +DECLARE_CLASS_FUNCTION (PwmOut, period_ms) +{ + CHECK_ARGUMENT_COUNT (PwmOut, period_ms, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, period_ms, 0, number); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + double arg0 = jerry_value_as_number (args[0]); + native_ptr->period_ms (static_cast<int> (arg0)); + + return jerry_undefined (); +} + +/** + * PwmOut#period_us (native JavaScript method) + * + * Set the PWM period, specified in micro-seconds (int), keeping the duty cycle the same. + */ +DECLARE_CLASS_FUNCTION (PwmOut, period_us) +{ + CHECK_ARGUMENT_COUNT (PwmOut, period_us, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, period_us, 0, number); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + double arg0 = jerry_value_as_number (args[0]); + native_ptr->period_us (static_cast<int> (arg0)); + + return jerry_undefined (); +} + +/** + * PwmOut#pulsewidth (native JavaScript method) + * + * Set the PWM pulsewidth, specified in seconds (float), keeping the period the same. + */ +DECLARE_CLASS_FUNCTION (PwmOut, pulsewidth) +{ + CHECK_ARGUMENT_COUNT (PwmOut, pulsewidth, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, pulsewidth, 0, number); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + double arg0 = jerry_value_as_number (args[0]); + native_ptr->pulsewidth (static_cast<float> (arg0)); + + return jerry_undefined (); +} + +/** + * PwmOut#pulsewidth_ms (native JavaScript method) + * + * Set the PWM pulsewidth, specified in milli-seconds (int), keeping the period the same. + */ +DECLARE_CLASS_FUNCTION (PwmOut, pulsewidth_ms) +{ + CHECK_ARGUMENT_COUNT (PwmOut, pulsewidth_ms, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, pulsewidth_ms, 0, number); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + double arg0 = jerry_value_as_number (args[0]); + native_ptr->pulsewidth_ms (static_cast<int> (arg0)); + + return jerry_undefined (); +} + +/** + * PwmOut#pulsewidth_us (native JavaScript method) + * + * Set the PWM pulsewidth, specified in micro-seconds (int), keeping the period the same. + */ +DECLARE_CLASS_FUNCTION (PwmOut, pulsewidth_us) +{ + CHECK_ARGUMENT_COUNT (PwmOut, pulsewidth_us, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, pulsewidth_us, 0, number); + + // Extract native PwmOut pointer + void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info); + + if (void_ptr == NULL) + { + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer"); + } + + PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr); + + double arg0 = jerry_value_as_number (args[0]); + native_ptr->pulsewidth_us (static_cast<int> (arg0)); + + return jerry_undefined (); +} + +/** + * PwmOut (native JavaScript constructor) + * + * @param pin_name mbed pin to connect the PwmOut to. + * @returns a JavaScript object representing a PwmOut. + */ +DECLARE_CLASS_CONSTRUCTOR (PwmOut) +{ + CHECK_ARGUMENT_COUNT (PwmOut, __constructor, args_count == 1); + CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, __constructor, 0, number); + + PinName pin_name = PinName (jerry_value_as_number (args[0])); + + // Create the native object + PwmOut* native_ptr = new PwmOut (pin_name); + + // create the jerryscript object + jerry_value_t js_object = jerry_object (); + jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr); + + // attach methods + ATTACH_CLASS_FUNCTION (js_object, PwmOut, write); + ATTACH_CLASS_FUNCTION (js_object, PwmOut, read); + ATTACH_CLASS_FUNCTION (js_object, PwmOut, period); + ATTACH_CLASS_FUNCTION (js_object, PwmOut, period_ms); + ATTACH_CLASS_FUNCTION (js_object, PwmOut, period_us); + ATTACH_CLASS_FUNCTION (js_object, PwmOut, pulsewidth); + ATTACH_CLASS_FUNCTION (js_object, PwmOut, pulsewidth_ms); + ATTACH_CLASS_FUNCTION (js_object, PwmOut, pulsewidth_us); + + return js_object; +} diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setInterval-js.cpp b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setInterval-js.cpp new file mode 100644 index 00000000..c8d9a5c3 --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setInterval-js.cpp @@ -0,0 +1,82 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "jerryscript-mbed-drivers/setInterval-js.h" + +#include "jerryscript-mbed-event-loop/EventLoop.h" + +/** + * setInterval (native JavaScript function) + * + * Call a JavaScript function at fixed intervals. + * + * @param function Function to call + * @param interval Time between function calls, in ms. + */ +DECLARE_GLOBAL_FUNCTION (setInterval) +{ + CHECK_ARGUMENT_COUNT (global, setInterval, (args_count == 2)); + CHECK_ARGUMENT_TYPE_ALWAYS (global, setInterval, 0, function); + CHECK_ARGUMENT_TYPE_ALWAYS (global, setInterval, 1, number); + + int interval = int (jerry_value_as_number (args[1])); + + int id = mbed::js::EventLoop::getInstance ().getQueue ().call_every (interval, + jerry_call, + args[0], + jerry_null (), + (jerry_value_t*) NULL, + 0); + + jerry_value_t result = jerry_object_set_index (call_info_p->function, id, args[0]); + + if (jerry_value_is_exception (result)) + { + jerry_value_free (result); + mbed::js::EventLoop::getInstance ().getQueue ().cancel (id); + + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to run setInterval"); + } + + jerry_value_free (result); + return jerry_number (id); +} + +/** + * clearInterval (native JavaScript function) + * + * Cancel an event that was previously scheduled via setInterval. + * + * @param id ID of the timeout event, returned by setInterval. + */ +DECLARE_GLOBAL_FUNCTION (clearInterval) +{ + CHECK_ARGUMENT_COUNT (global, clearInterval, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (global, clearInterval, 0, number); + + int id = int (jerry_value_as_number (args[0])); + + mbed::js::EventLoop::getInstance ().getQueue ().cancel (id); + + jerry_value_t global_obj = jerry_current_realm (); + jerry_value_t prop_name = jerry_string_sz ("setInterval"); + jerry_value_t func_obj = jerry_object_get (global_obj, prop_name); + jerry_value_free (prop_name); + + jerry_object_delete_index (func_obj, id); + jerry_value_free (func_obj); + jerry_value_free (global_obj); + + return jerry_undefined (); +} diff --git a/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setTimeout-js.cpp b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setTimeout-js.cpp new file mode 100644 index 00000000..a7eb32bb --- /dev/null +++ b/targets/os/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setTimeout-js.cpp @@ -0,0 +1,82 @@ +/* Copyright JS Foundation and other contributors, http://js.foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "jerryscript-mbed-drivers/setTimeout-js.h" + +#include "jerryscript-mbed-event-loop/EventLoop.h" + +/** + * setTimeout (native JavaScript function) + * + * Call a JavaScript function once, after a fixed time period. + * + * @param function Function to call + * @param wait_time Time before function is called, in ms. + */ +DECLARE_GLOBAL_FUNCTION (setTimeout) +{ + CHECK_ARGUMENT_COUNT (global, setTimeout, (args_count == 2)); + CHECK_ARGUMENT_TYPE_ALWAYS (global, setTimeout, 0, function); + CHECK_ARGUMENT_TYPE_ALWAYS (global, setTimeout, 1, number); + + int interval = int (jerry_value_as_number (args[1])); + + int id = mbed::js::EventLoop::getInstance ().getQueue ().call_in (interval, + jerry_call, + args[0], + jerry_null (), + (jerry_value_t*) NULL, + 0); + + jerry_value_t result = jerry_object_set_index (call_info_p->function, id, args[0]); + + if (jerry_value_is_exception (result)) + { + jerry_value_free (result); + mbed::js::EventLoop::getInstance ().getQueue ().cancel (id); + + return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to run setTimeout"); + } + + jerry_value_free (result); + return jerry_number (id); +} + +/** + * clearTimeout (native JavaScript function) + * + * Cancel an event that was previously scheduled via setTimeout. + * + * @param id ID of the timeout event, returned by setTimeout. + */ +DECLARE_GLOBAL_FUNCTION (clearTimeout) +{ + CHECK_ARGUMENT_COUNT (global, clearTimeout, (args_count == 1)); + CHECK_ARGUMENT_TYPE_ALWAYS (global, clearTimeout, 0, number); + + int id = int (jerry_value_as_number (args[0])); + + mbed::js::EventLoop::getInstance ().getQueue ().cancel (id); + + jerry_value_t global_obj = jerry_current_realm (); + jerry_value_t prop_name = jerry_string_sz ("setTimeout"); + jerry_value_t func_obj = jerry_object_get (global_obj, prop_name); + jerry_value_free (prop_name); + + jerry_object_delete_index (func_obj, id); + jerry_value_free (func_obj); + jerry_value_free (global_obj); + + return jerry_undefined (); +} |