static void iotjs_pwm_set_configuration(const iotjs_jval_t* jconfiguration, iotjs_pwm_t* pwm) { IOTJS_VALIDATED_STRUCT_METHOD(iotjs_pwm_t, pwm); iotjs_jval_t jpin = iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_PIN); _this->pin = iotjs_jval_as_number(&jpin); #if defined(__linux__) iotjs_jval_t jchip = iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_CHIP); _this->chip = iotjs_jval_as_number(&jchip); iotjs_jval_destroy(&jchip); #endif iotjs_jval_t jperiod = iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_PERIOD); if (iotjs_jval_is_number(&jperiod)) _this->period = iotjs_jval_as_number(&jperiod); iotjs_jval_t jduty_cycle = iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_DUTYCYCLE); if (iotjs_jval_is_number(&jduty_cycle)) _this->duty_cycle = iotjs_jval_as_number(&jduty_cycle); iotjs_jval_destroy(&jpin); iotjs_jval_destroy(&jperiod); iotjs_jval_destroy(&jduty_cycle); }
static jerry_value_t StatsIsTypeOf(jerry_value_t stats, int type) { jerry_value_t mode = iotjs_jval_get_property(stats, IOTJS_MAGIC_STRING_MODE); int mode_number = (int)iotjs_jval_as_number(mode); jerry_release_value(mode); return jerry_create_boolean((mode_number & S_IFMT) == type); }
static int iotjs_spi_get_array_data(char** buf, const iotjs_jval_t* jarray) { iotjs_jval_t jlength = iotjs_jval_get_property(jarray, IOTJS_MAGIC_STRING_LENGTH); IOTJS_ASSERT(!iotjs_jval_is_undefined(&jlength)); size_t length = iotjs_jval_as_number(&jlength); IOTJS_ASSERT((int)length >= 0); *buf = iotjs_buffer_allocate(length); for (size_t i = 0; i < length; i++) { iotjs_jval_t jdata = iotjs_jval_get_property_by_index(jarray, i); (*buf)[i] = iotjs_jval_as_number(&jdata); iotjs_jval_destroy(&jdata); } iotjs_jval_destroy(&jlength); return (int)length; }
static int spi_get_array_data(char** buf, jerry_value_t jarray) { jerry_value_t jlength = iotjs_jval_get_property(jarray, IOTJS_MAGIC_STRING_LENGTH); IOTJS_ASSERT(!jerry_value_is_undefined(jlength)); size_t length = iotjs_jval_as_number(jlength); IOTJS_ASSERT((int)length >= 0); *buf = iotjs_buffer_allocate(length); for (size_t i = 0; i < length; i++) { jerry_value_t jdata = iotjs_jval_get_property_by_index(jarray, i); (*buf)[i] = iotjs_jval_as_number(jdata); jerry_release_value(jdata); } jerry_release_value(jlength); return (int)length; }
size_t iotjs_bufferwrap_length(iotjs_bufferwrap_t* bufferwrap) { IOTJS_VALIDATED_STRUCT_METHOD(iotjs_bufferwrap_t, bufferwrap); #ifndef NDEBUG iotjs_jval_t jbuf = iotjs_bufferwrap_jbuffer(bufferwrap); iotjs_jval_t jlength = iotjs_jval_get_property(&jbuf, IOTJS_MAGIC_STRING_LENGTH); size_t length = iotjs_jval_as_number(&jlength); IOTJS_ASSERT(length == _this->length); iotjs_jval_destroy(&jbuf); iotjs_jval_destroy(&jlength); #endif return _this->length; }
static void iotjs_adc_set_configuration(iotjs_adc_t* adc, const iotjs_jval_t* jconfiguration) { #if defined(__linux__) IOTJS_VALIDATED_STRUCT_METHOD(iotjs_adc_t, adc); iotjs_jval_t jdevice = iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_DEVICE); _this->device = iotjs_jval_as_string(&jdevice); iotjs_jval_destroy(&jdevice); #elif defined(__NUTTX__) IOTJS_VALIDATED_STRUCT_METHOD(iotjs_adc_t, adc); iotjs_jval_t jpin = iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_PIN); _this->pin = iotjs_jval_as_number(&jpin); iotjs_jval_destroy(&jpin); #endif }
static void iotjs_spi_set_configuration(iotjs_spi_t* spi, const iotjs_jval_t* joptions) { IOTJS_VALIDATED_STRUCT_METHOD(iotjs_spi_t, spi); #if defined(__linux__) iotjs_jval_t jdevice = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_DEVICE); _this->device = iotjs_jval_as_string(&jdevice); iotjs_jval_destroy(&jdevice); #elif defined(__NUTTX__) || defined(__TIZENRT__) iotjs_jval_t jbus = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BUS); _this->bus = iotjs_jval_as_number(&jbus); iotjs_jval_destroy(&jbus); #endif iotjs_jval_t jmode = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MODE); _this->mode = (SpiMode)iotjs_jval_as_number(&jmode); iotjs_jval_destroy(&jmode); iotjs_jval_t jchip_select = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_CHIPSELECT); _this->chip_select = (SpiChipSelect)iotjs_jval_as_number(&jchip_select); iotjs_jval_destroy(&jchip_select); iotjs_jval_t jmax_speed = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MAXSPEED); _this->max_speed = iotjs_jval_as_number(&jmax_speed); iotjs_jval_destroy(&jmax_speed); iotjs_jval_t jbits_per_word = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITSPERWORD); _this->bits_per_word = (SpiOrder)iotjs_jval_as_number(&jbits_per_word); iotjs_jval_destroy(&jbits_per_word); iotjs_jval_t jbit_order = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITORDER); _this->bit_order = (SpiOrder)iotjs_jval_as_number(&jbit_order); iotjs_jval_destroy(&jbit_order); iotjs_jval_t jloopback = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_LOOPBACK); _this->loopback = iotjs_jval_as_boolean(&jloopback); iotjs_jval_destroy(&jloopback); }
static jerry_value_t gpio_set_configuration(iotjs_gpio_t* gpio, jerry_value_t jconfigurable) { jerry_value_t jpin = iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_PIN); gpio->pin = iotjs_jval_as_number(jpin); jerry_release_value(jpin); // Direction jerry_value_t jdirection = iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_DIRECTION); if (jerry_value_is_undefined(jdirection)) { gpio->direction = kGpioDirectionOut; } else { if (jerry_value_is_number(jdirection)) { gpio->direction = (GpioDirection)iotjs_jval_as_number(jdirection); } else { gpio->direction = __kGpioDirectionMax; } if (gpio->direction >= __kGpioDirectionMax) { return JS_CREATE_ERROR( TYPE, "Bad arguments - gpio.direction should be DIRECTION.IN or OUT"); } } jerry_release_value(jdirection); // Mode jerry_value_t jmode = iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_MODE); if (jerry_value_is_undefined(jmode)) { gpio->mode = kGpioModeNone; } else { if (jerry_value_is_number(jmode)) { gpio->mode = (GpioMode)iotjs_jval_as_number(jmode); } else { gpio->mode = __kGpioModeMax; } if (gpio->mode >= __kGpioModeMax) { return JS_CREATE_ERROR(TYPE, "Bad arguments - gpio.mode should be MODE.NONE, " "PULLUP, PULLDOWN, FLOAT, PUSHPULL or OPENDRAIN"); } else if (gpio->direction == kGpioDirectionIn && gpio->mode != kGpioModeNone && gpio->mode != kGpioModePullup && gpio->mode != kGpioModePulldown) { return JS_CREATE_ERROR(TYPE, "Bad arguments - DIRECTION.IN only supports " "MODE.NONE, PULLUP and PULLDOWN"); } else if (gpio->direction == kGpioDirectionOut && gpio->mode != kGpioModeNone && gpio->mode != kGpioModeFloat && gpio->mode != kGpioModePushpull && gpio->mode != kGpioModeOpendrain) { return JS_CREATE_ERROR(TYPE, "Bad arguments - DIRECTION.OUT only supports " "MODE.NONE, FLOAT, PUSHPULL and OPENDRAIN"); } } jerry_release_value(jmode); // Edge jerry_value_t jedge = iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_EDGE); if (jerry_value_is_undefined(jedge)) { gpio->edge = kGpioEdgeNone; } else { if (jerry_value_is_number(jedge)) { gpio->edge = (GpioEdge)iotjs_jval_as_number(jedge); } else { gpio->edge = __kGpioEdgeMax; } if (gpio->edge >= __kGpioEdgeMax) { return JS_CREATE_ERROR(TYPE, "Bad arguments - gpio.edge should be EDGE.NONE, " "RISING, FALLING or BOTH"); } } jerry_release_value(jedge); return jerry_create_undefined(); }
/* Default configuration: *{ * mode: spi.MODE[0], * chipSelect: spi.CHIPSELECT.NONE, * maxSpeed: 500000, * bitsPerWord: 8, * bitOrder: spi.BITORDER.MSB, * loopback: false * } */ static jerry_value_t spi_set_configuration(iotjs_spi_t* spi, jerry_value_t joptions) { jerry_value_t jmode = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MODE); if (jerry_value_is_undefined(jmode)) { spi->mode = kSpiMode_0; } else { if (jerry_value_is_number(jmode)) { spi->mode = (SpiMode)iotjs_jval_as_number(jmode); } else { spi->mode = __kSpiModeMax; } if (spi->mode >= __kSpiModeMax) { return JS_CREATE_ERROR( TYPE, "Bad arguments - mode should be MODE[0], [1], [2] or [3]"); } } jerry_release_value(jmode); jerry_value_t jchip_select = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_CHIPSELECT); if (jerry_value_is_undefined(jchip_select)) { spi->chip_select = kSpiCsNone; } else { if (jerry_value_is_number(jchip_select)) { spi->chip_select = (SpiChipSelect)iotjs_jval_as_number(jchip_select); } else { spi->chip_select = __kSpiCsMax; } if (spi->chip_select >= __kSpiCsMax) { return JS_CREATE_ERROR( TYPE, "Bad arguments - chipSelect should be CHIPSELECT.NONE or HIGH"); } } jerry_release_value(jchip_select); jerry_value_t jmax_speed = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MAXSPEED); if (jerry_value_is_undefined(jmax_speed)) { spi->max_speed = 500000; } else { if (!jerry_value_is_number(jmax_speed)) { return JS_CREATE_ERROR(TYPE, "Bad arguments - maxSpeed should be Number"); } spi->max_speed = iotjs_jval_as_number(jmax_speed); } jerry_release_value(jmax_speed); jerry_value_t jbits_per_word = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITSPERWORD); if (jerry_value_is_undefined(jbits_per_word)) { spi->bits_per_word = 8; } else { if (jerry_value_is_number(jbits_per_word)) { spi->bits_per_word = iotjs_jval_as_number(jbits_per_word); } else { spi->bits_per_word = 0; } if (spi->bits_per_word != 8 && spi->bits_per_word != 9) { return JS_CREATE_ERROR(TYPE, "Bad arguments - bitsPerWord should be 8 or 9"); } } jerry_release_value(jbits_per_word); jerry_value_t jbit_order = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITORDER); if (jerry_value_is_undefined(jbit_order)) { spi->bit_order = kSpiOrderMsb; } else { if (jerry_value_is_number(jbit_order)) { spi->bit_order = (SpiOrder)iotjs_jval_as_number(jbit_order); } else { spi->bit_order = __kSpiOrderMax; } if (spi->bit_order >= __kSpiOrderMax) { return JS_CREATE_ERROR( TYPE, "Bad arguments - bitOrder should be BITORDER.MSB or LSB"); } } jerry_release_value(jbit_order); jerry_value_t jloopback = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_LOOPBACK); if (jerry_value_is_undefined(jloopback)) { spi->loopback = false; } else { if (!jerry_value_is_boolean(jloopback)) { return JS_CREATE_ERROR(TYPE, "Bad arguments - loopback should be Boolean"); } spi->loopback = iotjs_jval_as_boolean(jloopback); } jerry_release_value(jloopback); return jerry_create_undefined(); }