static be_jse_symbol_t* send()
{
be_jse_int_t ret = -1;
be_jse_symbol_t* arg0 = NULL;
be_jse_symbol_t* arg1 = NULL;
be_jse_symbol_t* arg2 = NULL;
be_jse_handle_function(0, &arg0, &arg1, &arg2, NULL);
if (arg0 == NULL || arg1 == NULL || arg2 == NULL
|| symbol_str_len(arg1) == 0 || !symbol_is_int(arg2)) {
ret = -2;
goto end;
}
size_t msg_size = symbol_str_len(arg1);
if (msg_size > BONE_ZIGBEE_BUFFER_SIZE) {
ret = -3;
goto end;
}
char add_str[12] = {0};
symbol_to_str(arg0, add_str, symbol_str_len(arg0));
char msg[BONE_ZIGBEE_BUFFER_SIZE] = {0};
symbol_to_str(arg1, msg, msg_size);
ret = bone_zigbee_send(&zigbee, atoi(add_str), (unsigned char*)msg, msg_size, (int)get_symbol_int(arg2));
end:
symbol_unlock(arg0);
symbol_unlock(arg1);
symbol_unlock(arg2);
return new_int_symbol(ret);
}
static be_jse_symbol_t* on()
{
be_jse_int_t ret = -1;
be_jse_symbol_t* arg0 = NULL;
be_jse_symbol_t* arg1 = NULL;
be_jse_handle_function(0, &arg0, &arg1, NULL, NULL);
if (arg0 == NULL || arg1 == NULL || !symbol_is_string(arg0) || !symbol_is_function(arg1)) {
ret = -1;
symbol_unlock(arg1);
goto end;
}
char name[32] = {0};
symbol_to_str(arg0, name, symbol_str_len(arg0));
/*
若有多次调用on
需要释放上一次的 on_xxx_func
*/
if (strcmp(name, "message") == 0) {
symbol_unlock(on_message_func);
on_message_func = arg1;
} else if (strcmp(name, "connect") == 0) {
symbol_unlock(on_connect_func);
on_connect_func = arg1;
} else if (strcmp(name, "error") == 0) {
symbol_unlock(on_error_func);
on_error_func = arg1;
}
end:
symbol_unlock(arg0);
return new_int_symbol(ret);
}
static be_jse_symbol_t* module_net_send()
{
be_jse_symbol_t *arg0 = NULL,*arg1 = NULL;
int ret = -1;int sock_id = 0;
char *data = NULL;
send_data_t *p_send_data= NULL;
be_jse_handle_function(0, &arg0,&arg1,NULL,NULL);
if ( (arg0 == NULL) || !symbol_is_int(arg0)
|| (arg1 == NULL) || !symbol_is_string(arg1)){
be_error(JS_NET_TAG,"module_net_connect param invalid");
goto done;
}
sock_id = get_symbol_value_int(arg0);
data = calloc(1,symbol_str_len(arg1)+1);
if (!data) goto done;
symbol_to_str(arg1, data, symbol_str_len(arg1));
be_debug(JS_NET_TAG,"NET.send(%d,%s)",sock_id,data);
p_send_data = calloc(1,sizeof(send_data_t));
p_send_data->p_data = data;
p_send_data->sock_id = sock_id;
ret = be_osal_new_task("net_connect",task_net_send_fun,p_send_data,4096,NULL);
if (ret < 0){
free(p_send_data);
free(p_send_data->p_data);
}
done:
symbol_unlock(arg0);
symbol_unlock(arg1);
return new_int_symbol(ret);
}
/*********************************************************
*Function: module_net_connect
*Description: js native addon for NET.connect
*Called by: js api
*Input: NET.connect(options),options is a object like this
{ addr: 'tcp://127.0.0.1:1234',
onconnect: function(conn) {},
ondata: function(conn, data){},
onclose: function(conn) {},
onerror: function(err) {},
}
*Output: 0 try connect ok ,other try connect fail
*********************************************************/
static be_jse_symbol_t* module_net_connect()
{
be_jse_symbol_t *arg0 = NULL;
int ret = -1;
be_jse_handle_function(0, &arg0,NULL,NULL,NULL);
if ( (arg0 == NULL) || !symbol_is_object(arg0) ){
be_error(JS_NET_TAG,"module_net_connect param invalid");
goto done;
}
be_jse_symbol_t* addrNetSymbol = unlock_symbol_value(lookup_named_child_symbol(get_symbol_node_id(arg0),"addr", false));
be_jse_symbol_t* onConnNetSymbol = unlock_symbol_value(lookup_named_child_symbol(get_symbol_node_id(arg0), "onconnect", false));
be_jse_symbol_t* onDataNetSymbol = unlock_symbol_value(lookup_named_child_symbol(get_symbol_node_id(arg0), "ondata", false));
be_jse_symbol_t* onCloseNetSymbol = unlock_symbol_value(lookup_named_child_symbol(get_symbol_node_id(arg0), "onclose", false));
be_jse_symbol_t* onErrorNetSymbol = unlock_symbol_value(lookup_named_child_symbol(get_symbol_node_id(arg0), "onerror", false));
if ( addrNetSymbol == NULL || onConnNetSymbol == NULL ){
be_error(JS_NET_TAG,"module_net_connect param invalid");
goto done;
}
net_options_t *p_net_options = calloc(1,sizeof(net_options_t));
p_net_options->addr = calloc(1,symbol_str_len(addrNetSymbol) + 1);
if (!p_net_options || p_net_options->addr == NULL) goto done;
/*because be_jse_async_event_cb will auto DEC_SYMBL_REF func,so need INC_SYMBL_REF before*/
symbol_to_str(addrNetSymbol, p_net_options->addr, symbol_str_len(addrNetSymbol));
symbol_unlock(addrNetSymbol);
if(onConnNetSymbol && symbol_is_function(onConnNetSymbol)){
p_net_options->onconn_cb = (onconnect)onConnNetSymbol;
INC_SYMBL_REF(onConnNetSymbol);
}
if(onDataNetSymbol && symbol_is_function(onDataNetSymbol)){
p_net_options->ondata_cb = (ondata)onDataNetSymbol;
INC_SYMBL_REF(onDataNetSymbol);
}
if(onCloseNetSymbol && symbol_is_function(onCloseNetSymbol)){
p_net_options->onclose_cb = (onclose)onCloseNetSymbol;
INC_SYMBL_REF(onCloseNetSymbol);
}
if(onErrorNetSymbol && symbol_is_function(onErrorNetSymbol)){
p_net_options->onerror_cb = (onerror)onErrorNetSymbol;
INC_SYMBL_REF(onErrorNetSymbol);
}
ret = be_osal_new_task("net_connect",task_net_connect_fun,p_net_options,4096,NULL);
done:
symbol_unlock(arg0);
return new_int_symbol(ret);
}
static be_jse_symbol_t *i2c_open(void)
{
int32_t len = -1;
char *data = NULL;
int8_t ret = -1;
int8_t result = -1;
item_handle_t i2c_handle;
i2c_handle.handle = 0xFFFFFFFF;
be_jse_symbol_t *arg0 = NULL;
i2c_dev_t *i2c_device = NULL;
be_jse_handle_function(0, &arg0, NULL, NULL, NULL);
if (!arg0 || !symbol_is_string(arg0)) {
goto out;
}
len = symbol_str_len(arg0);
data = calloc(1, sizeof(char) * (len + 1));
if (NULL == data) {
goto out;
}
symbol_to_str(arg0, data, len);
ret = board_attach_item(MODULE_I2C, data, &i2c_handle);
if (0 != ret) {
be_error("i2c", "board_attach_item fail!\n");
goto out;
}
be_debug("i2c", "i2c handle:%u\n", i2c_handle.handle);
i2c_device = board_get_node_by_handle(MODULE_I2C, &i2c_handle);
if (NULL == i2c_device) {
be_error("i2c", "board_get_node_by_handle fail!\n");
goto out;
}
ret = hal_i2c_init(i2c_device);
if (0 != ret) {
be_error("i2c", "hal_i2c_init fail!\n");
goto out;
}
result = 0;
out:
if (NULL != data) {
free(data);
data = NULL;
}
symbol_unlock(arg0);
if (0 != result) {
board_disattach_item(MODULE_I2C, &i2c_handle);
return new_int_symbol(-1);
}
return new_int_symbol(i2c_handle.handle);
}
static be_jse_symbol_t * uart_write(void){
int8_t ret = -1;
int8_t result = -1;
char * data = NULL;
uint32_t len = 0;
item_handle_t uart_handle;
be_jse_symbol_t * arg0 = NULL;
be_jse_symbol_t * arg1 = NULL;
uart_dev_t * uart_device = NULL;
be_jse_handle_function(0,&arg0,&arg1,NULL,NULL);
if(!arg0 || !symbol_is_int(arg0)){
goto out;
}
uart_handle.handle = get_symbol_value_int(arg0);
uart_device = board_get_node_by_handle(MODULE_UART,&uart_handle);
if(NULL == uart_device){
be_error("uart","board_get_node_by_handle fail!\n");
goto out;
}
if(!arg1 || !symbol_is_string(arg1)){
goto out;
}
len = symbol_str_len(arg1);
data = calloc(1,sizeof(char)*(len+1));
if(NULL==data){
goto out;
}
symbol_to_str(arg1,data,len);
ret = hal_uart_send(uart_device,data,len,0);
if(-1 == ret){
be_error("uart","hal_uart_send fail!\n");
goto out;
}
result = 0;
out:
symbol_unlock(arg0);
symbol_unlock(arg1);
if(NULL != data){
free(data);
data = NULL;
}
return new_int_symbol(len);
}
/**
* Adds a transition to 'automaton'.
*/
void add_transition(SingleGraph automaton,struct string_hash_ptr* symbols,int from,
symbol_t* label,int to) {
if (label==SYMBOL_DEF) {
if (automaton->states[from]->default_state!=-1) {
fatal_error("add_transition: more than one default transition\n");
}
automaton->states[from]->default_state=to;
return;
}
while (label!=NULL) {
if (label==SYMBOL_DEF) {
fatal_error("add_transition: unexpected default transition\n");
}
/* We build a string representation of the symbol to avoid
* duplicates in the value array */
Ustring* u=new_Ustring();
symbol_to_str(label,u);
int n=get_value_index(u->str,symbols,INSERT_IF_NEEDED,label);
free_Ustring(u);
add_outgoing_transition(automaton->states[from],n,to);
label=label->next;
}
}
static be_jse_symbol_t* start()
{
be_jse_int_t ret = -1;
be_jse_symbol_t* arg = be_jse_handle_single_arg_function();
be_jse_symbol_t* port_symbol = NULL;
be_jse_symbol_t* service_symbol = NULL;
be_jse_symbol_t* uart_port_symbol = NULL;
be_jse_symbol_t* uart_baudrate_symbol = NULL;
be_jse_symbol_t* value_port_symbol = NULL;
be_jse_symbol_t* value_service_symbol = NULL;
be_jse_symbol_t* value_uart_port_symbol = NULL;
be_jse_symbol_t* value_uart_baudrate_symbol = NULL;
if (arg == NULL)
goto end;
port_symbol = lookup_named_child_symbol(get_symbol_node_id(arg), "port", false);
service_symbol = lookup_named_child_symbol(get_symbol_node_id(arg), "service", false);
uart_port_symbol = lookup_named_child_symbol(get_symbol_node_id(arg), "uartPort", false);
uart_baudrate_symbol = lookup_named_child_symbol(get_symbol_node_id(arg), "uartBaudrate", false);
if (port_symbol == NULL || service_symbol == NULL
|| uart_port_symbol == NULL || uart_baudrate_symbol == NULL) {
ret = -2;
goto end;
}
value_port_symbol = get_symbol_value(port_symbol);
value_service_symbol = get_symbol_value(service_symbol);
value_uart_port_symbol = get_symbol_value(uart_port_symbol);
value_uart_baudrate_symbol = get_symbol_value(uart_baudrate_symbol);
if (value_port_symbol == NULL || value_service_symbol == NULL
|| value_uart_port_symbol == NULL || value_uart_baudrate_symbol == NULL) {
ret = -3;
goto end;
}
zigbee.uart_dev.port = (uint8_t)get_symbol_int(value_uart_port_symbol);
zigbee.uart_dev.config.baud_rate = (uint32_t)get_symbol_int(value_uart_baudrate_symbol);
zigbee.uart_dev.config.data_width = DATA_WIDTH_8BIT;
zigbee.uart_dev.config.parity = NO_PARITY;
zigbee.uart_dev.config.stop_bits = STOP_BITS_1;
zigbee.uart_dev.config.flow_control = FLOW_CONTROL_DISABLED;
zigbee.on_message = on_message;
zigbee.on_connect = on_connect;
zigbee.port = (uint8_t)get_symbol_int(value_port_symbol);
symbol_to_str(value_service_symbol, zigbee.nt, symbol_str_len(value_service_symbol));
ret = bone_zigbee_start(&zigbee);
end:
symbol_unlock(arg);
symbol_unlock(port_symbol);
symbol_unlock(service_symbol);
symbol_unlock(uart_port_symbol);
symbol_unlock(uart_baudrate_symbol);
symbol_unlock(value_port_symbol);
symbol_unlock(value_service_symbol);
symbol_unlock(value_uart_port_symbol);
symbol_unlock(value_uart_baudrate_symbol);
return new_int_symbol(ret);
}
