Ejemplo n.º 1
0
void ICACHE_FLASH_ATTR finger_handler(
	struct espconn *pConnection, 
	request_method method, 
	char *url, 
	char *data, 
	uint16 data_len, 
	uint32 content_len, 
	char *response,
	uint16 response_len
) {
	if (device_get_uart() != UART_FINGER) {
		json_error(response, MOD_FINGER, DEVICE_NOT_FOUND, NULL);
		return;
	}
	
	struct jsonparse_state parser;
	int type, delete_len;
	uint16 delete_id;
	
	if (method == POST && data != NULL && data_len != 0) {
		jsonparse_setup(&parser, data, data_len);
		
		while ((type = jsonparse_next(&parser)) != 0) {
			if (type == JSON_TYPE_PAIR_NAME) {
				if (jsonparse_strcmp_value(&parser, "Address") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					
					char *convert_err = NULL;
					char address_str[20];
					jsonparse_copy_value(&parser, address_str, 20);
					uint32 address = strtoul(address_str, &convert_err, 16);
					
					if (*convert_err == '\0' && address != finger_address()) {
						finger_set_address(address, finger_default);
					}
				} else if (jsonparse_strcmp_value(&parser, "SecurityLevel") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					uint8 security_level = jsonparse_get_value_as_int(&parser);
					
					if (security_level != finger_security_level()) {
						finger_set_security_lefel(security_level, finger_default);
					}
				} else if (jsonparse_strcmp_value(&parser, "Mode") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					if (jsonparse_strcmp_value(&parser, "Read") == 0) {
						finger_current_mode = FINGER_READ;
					} else if (jsonparse_strcmp_value(&parser, "New") == 0) {
						finger_current_mode = FINGER_NEW;
					} else if (jsonparse_strcmp_value(&parser, "Delete") == 0) {
						finger_current_mode = FINGER_DELETE;
					} else if (jsonparse_strcmp_value(&parser, "Empty DB") == 0) {
						finger_current_mode = FINGER_EMPTY_DB;
					}
				} else if (jsonparse_strcmp_value(&parser, "DeleteID") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					delete_id = jsonparse_get_value_as_int(&parser);
					delete_len = jsonparse_get_len(&parser);
				}
			}
		}
		
		if (finger_current_mode == FINGER_DELETE && delete_len > 0) {
			finger_current_mode = FINGER_READ;
			finger_remove(delete_id, NULL);
#if FINGER_DEBUG
			debug("FINGER: Delete ID: %d\n", delete_id);
#endif
		}
		
		if (finger_current_mode == FINGER_EMPTY_DB) {
			finger_current_mode = FINGER_READ;
			finger_empty_db(NULL);
#if FINGER_DEBUG
			debug("FINGER: Empty DB\n");
#endif
		}
	}
	
	webserver_set_status(0);
	finger_frech_params();
	finger_start_read();
}
Ejemplo n.º 2
0
void ICACHE_FLASH_ATTR dimmer_handler(
	struct espconn *pConnection, 
	request_method method, 
	char *url, 
	char *data, 
	uint16 data_len, 
	uint32 content_len, 
	char *response,
	uint16 response_len
) {
	i2c_status status = I2C_OK;
	i2c_config *config = i2c_init_handler(DIMMER_STR, DIMMER_URL, dimmer_init, url, response);
	if (config == NULL) {
		return;
	}
	
	dimmer_config_data *config_data = (dimmer_config_data *)config->data;
	
	struct jsonparse_state parser;
	int type;

	if (method == POST && data != NULL && data_len != 0) {
		jsonparse_setup(&parser, data, data_len);

		while ((type = jsonparse_next(&parser)) != 0) {
			if (type == JSON_TYPE_PAIR_NAME) {
				if (jsonparse_strcmp_value(&parser, "Relay") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					config_data->relay = jsonparse_get_value_as_int(&parser);
				} else if (jsonparse_strcmp_value(&parser, "Brightness") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					config_data->brightness = jsonparse_get_value_as_int(&parser);
				} else if (jsonparse_strcmp_value(&parser, "Refresh") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					dimmer_refresh = jsonparse_get_value_as_int(&parser) * 1000;
				} else if (jsonparse_strcmp_value(&parser, "Each") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					dimmer_each = jsonparse_get_value_as_int(&parser);
				} else if (jsonparse_strcmp_value(&parser, "Threshold") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					dimmer_threshold = jsonparse_get_value_as_int(&parser);
				}
			}
		}
		
		dimmer_timer_init();
		status = dimmer_set(config);
	}
	
	char address_str[MAX_I2C_ADDRESS];
	json_i2c_address(address_str, config->address);
	
	if (status == I2C_OK) {
		dimmer_response(config, response, true);
	} else {
		json_error(response, DIMMER_STR, i2c_status_str(status), address_str);
	}
}
Ejemplo n.º 3
0
int ICACHE_FLASH_ATTR cgiSched(HttpdConnData *connData) {
	struct sched_entry *s = config.scheds;

	os_printf("post len=%d %s\n",connData->post->len, connData->post->buff);

	if (connData->post->len > 10)
	{

		set_all_relays_off();

		config.sched_count = 0;
		s = config.scheds;

		struct jsonparse_state j;
		jsonparse_setup(&j, connData->post->buff, connData->post->len);

		int type;
		while ( (type = jsonparse_next(&j) ) != 0)
		{
			if (type == JSON_TYPE_PAIR_NAME) {
				if (jsonparse_strcmp_value(&j, "schedules") == 0) {
					jsonparse_next(&j);
					while ( (type = jsonparse_next(&j) ) != 0)
					{
						if (type == JSON_TYPE_ARRAY || type == ',')
						{
							jsonparse_next(&j);
							while ( (type = jsonparse_next(&j) ) != 0)
							{
								if (type == '}')
								{
									s++;
									config.sched_count++;
									break;
								}
								if (type == JSON_TYPE_PAIR_NAME) {
									if (jsonparse_strcmp_value(&j, "zone") == 0) {
										jsonparse_next(&j);
										jsonparse_next(&j);
										s->zone = jsonparse_get_value_as_int(&j);
									}
									if (jsonparse_strcmp_value(&j, "start") == 0) {
										jsonparse_next(&j);
										jsonparse_next(&j);
										s->start = jsonparse_get_value_as_int(&j);
									}
									if (jsonparse_strcmp_value(&j, "end") == 0) {
										jsonparse_next(&j);
										jsonparse_next(&j);
										s->end = jsonparse_get_value_as_int(&j);
									}
									if (jsonparse_strcmp_value(&j, "time") == 0) {
										jsonparse_next(&j);
										jsonparse_next(&j);
										s->time = jsonparse_get_value_as_int(&j);
									}
									if (jsonparse_strcmp_value(&j, "duration") == 0) {
										jsonparse_next(&j);
										jsonparse_next(&j);
										s->duration = jsonparse_get_value_as_int(&j);
									}
									if (jsonparse_strcmp_value(&j, "repeat") == 0) {
										jsonparse_next(&j);
										jsonparse_next(&j);
										s->repeat = jsonparse_get_value_as_int(&j);
									}
									if (jsonparse_strcmp_value(&j, "dow") == 0) {
										jsonparse_next(&j);
										jsonparse_next(&j);
										s->dow = jsonparse_get_value_as_int(&j);
									}
								}
							}
						}
					}
				}
			}
		}
		save_config();
		compute_times();
	}

	char *data = (char *)alloca(100*config.sched_count);
	char *p = data;
	s = config.scheds;
	int i;
	os_sprintf(p,"{ \"name\": \"%s\", \"time\": %d, \"schedules\":[ ",config.myname,time());
	p += strlen(p);
	for (i = config.sched_count, s = config.scheds; i > 0; i--, s++)
	{
		os_sprintf(p,"{\"zone\":%d,\"start\":%d,\"end\":%d,\"time\":%d,\"duration\":%d,\"repeat\":%d,\"dow\":%d},",
				s->zone,s->start,s->end,s->time,s->duration,s->repeat,s->dow);
		p += strlen(p);
	}
	p--;
	*p++ = ']';
	*p++ = '}';
	*p++ = '\0';
	httpdSend(connData, data, -1);
	return HTTPD_CGI_DONE;
}
Ejemplo n.º 4
0
int ICACHE_FLASH_ATTR cgiConfig(HttpdConnData *connData) {
	//os_printf("post len=%d %s\n",connData->post->len, connData->post->buff);
	char data[100];

	if (connData->post->len > 4)
	{
		struct jsonparse_state j;
		jsonparse_setup(&j, connData->post->buff, connData->post->len);
		int type;
		while ( (type = jsonparse_next(&j) ) != 0)
		{
			if (type == JSON_TYPE_PAIR_NAME) {
				if (jsonparse_strcmp_value(&j, "reset") == 0) {
					start_reset();
					os_sprintf(data,"{ \"reset\":\"Device reset in 2 seconds\" }");
					httpdSend(connData, data, -1);
					return HTTPD_CGI_DONE;
				}
				if (jsonparse_strcmp_value(&j, "config") == 0) {
					jsonparse_next(&j);
					while ( (type = jsonparse_next(&j) ) != 0)
					{
						if (type == JSON_TYPE_PAIR_NAME) {
							if (jsonparse_strcmp_value(&j, "name") == 0) {
								jsonparse_next(&j);
								jsonparse_next(&j);
								jsonparse_copy_value(&j, config.myname, sizeof(config.myname));
							}
							if (jsonparse_strcmp_value(&j, "zoffset") == 0) {
								jsonparse_next(&j);
								jsonparse_next(&j);
								// the following doesn't work with negative numbers
								//config.zoffset = jsonparse_get_value_as_int(&j);
								// so we do it the hard way
								char data[20];
								jsonparse_copy_value(&j, data, sizeof(data));
								// ok so atoi() doesn't work either
								config.zoffset = atoi(data);
#if 0
								if (data[0] == '-')
								{
									config.zoffset = 0 - atoi(data+1);
								}
								else
								{
									config.zoffset = atoi(data);
								}
#endif
								os_printf("zofffset=%d %08x\n",config.zoffset,config.zoffset);
							}
						}
					}
				}
			}
		}
		save_config();
	}
	os_sprintf(data,"{ config: { \"name\": \"%s\", \"zoffset\":%d } }",config.myname,config.zoffset);
	httpdSend(connData, data, -1);
	return HTTPD_CGI_DONE;
}
Ejemplo n.º 5
0
void ICACHE_FLASH_ATTR emtr_handler(
	struct espconn *pConnection, 
	request_method method, 
	char *url, 
	char *data, 
	uint16 data_len, 
	uint32 content_len, 
	char *response,
	uint16 response_len
) {
	if (device_get_uart() != UART_EMTR) {
		json_error(response, MOD_EMTR, DEVICE_NOT_FOUND, NULL);
		return;
	}
	
	if (emtr_registers.calibration == NULL) {
		emtr_registers.calibration = (emtr_calibration_registers *)os_zalloc(sizeof(emtr_calibration_registers));
	}
	
	if (emtr_registers.event == NULL) {
		emtr_registers.event = (emtr_event_registers *)os_zalloc(sizeof(emtr_event_registers));
	}
		
	struct jsonparse_state parser;
	int type;
	bool set_counter = false;
	emtr_mode mode = emtr_current_mode;
	_uint64_ counter_active = emtr_counter_active();
	_uint64_ counter_apparent = emtr_counter_apparent();
	
	if (method == POST && data != NULL && data_len != 0) {
		jsonparse_setup(&parser, data, data_len);
		
		while ((type = jsonparse_next(&parser)) != 0) {
			if (type == JSON_TYPE_PAIR_NAME) {
				if (jsonparse_strcmp_value(&parser, "Mode") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					if (jsonparse_strcmp_value(&parser, "Log") == 0) {
						emtr_current_mode = EMTR_LOG;
					} else if (jsonparse_strcmp_value(&parser, "Configure") == 0) {
						emtr_current_mode = EMTR_CONFIGURE;
					} else if (jsonparse_strcmp_value(&parser, "Calibration") == 0) {
						emtr_current_mode = EMTR_CALIBRATION;
					}
				} else if (jsonparse_strcmp_value(&parser, "ReadInterval") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					emtr_read_interval = jsonparse_get_value_as_int(&parser);
				} else if (jsonparse_strcmp_value(&parser, "CounterActive") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					counter_active = jsonparse_get_value_as_int(&parser);
					set_counter = true;
				} else if (jsonparse_strcmp_value(&parser, "CounterApparent") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					counter_apparent = jsonparse_get_value_as_int(&parser);
					set_counter = true;
				}
				
				if (mode == EMTR_CONFIGURE) {
					if (jsonparse_strcmp_value(&parser, "OverCurrentLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_current_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "OverPowerLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_power_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "OverFrequencyLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_frequency_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "UnderFrequencyLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->under_frequency_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "OverTemperatureLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_temperature_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "UnderTemperatureLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->under_temperature_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "VoltageSagLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->voltage_sag_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "VoltageSurgeLimit") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->voltage_surge_limit = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "OverCurrentHold") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_current_hold = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "OverPowerHold") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_power_hold = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "OverFrequencyHold") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_frequency_hold = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "UnderFrequencyHold") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->under_frequency_hold = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "OverTemperatureHold") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->over_temperature_hold = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "UnderTemperatureHold") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->under_temperature_hold = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "EventEnable") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->event_enable = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "EventMaskCritical") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->event_mask_critical = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "EventMaskStandard") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->event_mask_standard = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "EventTest") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->event_test = jsonparse_get_value_as_int(&parser);
					} else if (jsonparse_strcmp_value(&parser, "EventClear") == 0) {
						jsonparse_next(&parser);
						jsonparse_next(&parser);
						emtr_registers.event->event_clear = jsonparse_get_value_as_int(&parser);
					}
				}
			}
		}
		
		if (mode == EMTR_CONFIGURE) {
			emtr_set_event(emtr_registers.event, NULL);
		}
		
		if (set_counter) {
			emtr_set_counter(counter_active, counter_apparent, NULL);
		}
	}
	
	char data_str[WEBSERVER_MAX_RESPONSE_LEN];
	if (emtr_current_mode == EMTR_CALIBRATION) {
		json_data(
			response, MOD_EMTR, OK_STR,
			json_sprintf(
				data_str,
				"\"Address\" : \"0x%04X\", "
				"\"Mode\" : \"%s\", "
				"\"CounterActive\" : %d, "
				"\"CounterApparent\" : %d, "
				"\"ReadInterval\" : %d, "
				
				"\"GainCurrentRMS\" : %d, "
				"\"GainVoltageRMS\" : %d, "
				"\"GainActivePower\" : %d, "
				"\"GainReactivePower\" : %d, "
				"\"OffsetCurrentRMS\" : %d, "
				"\"OffsetActivePower\" : %d, "
				"\"OffsetReactivePower\" : %d, "
				"\"DCOffsetCurrent\" : %d, "
				"\"PhaseCompensation\" : %d, "
				"\"ApparentPowerDivisor\" : %d, "
				"\"SystemConfiguration\" : \"0x%08X\", "
				"\"DIOConfiguration\" : \"0x%04X\", "
				"\"Range\" : \"0x%08X\", "
				
				"\"CalibrationCurrent\" : %d, "
				"\"CalibrationVoltage\" : %d, "
				"\"CalibrationActivePower\" : %d, "
				"\"CalibrationReactivePower\" : %d, "
				"\"AccumulationInterval\" : %d",
				emtr_address(),
				emtr_mode_str(emtr_current_mode),
				emtr_counter_active(),
				emtr_counter_apparent(),
				emtr_read_interval,
				
				emtr_registers.calibration->gain_current_rms,
				emtr_registers.calibration->gain_voltage_rms,
				emtr_registers.calibration->gain_active_power,
				emtr_registers.calibration->gain_reactive_power,
				emtr_registers.calibration->offset_current_rms,
				emtr_registers.calibration->offset_active_power,
				emtr_registers.calibration->offset_reactive_power,
				emtr_registers.calibration->dc_offset_current,
				emtr_registers.calibration->phase_compensation,
				emtr_registers.calibration->apparent_power_divisor,
				emtr_registers.calibration->system_configuration,
				emtr_registers.calibration->dio_configuration,
				emtr_registers.calibration->range,
				
				emtr_registers.calibration->calibration_current,
				emtr_registers.calibration->calibration_voltage,
				emtr_registers.calibration->calibration_active_power,
				emtr_registers.calibration->calibration_reactive_power,
				emtr_registers.calibration->accumulation_interval
			),
			NULL
		);
		setTimeout(emtr_calibration_read, NULL, 1500);
	} else if (emtr_current_mode == EMTR_CONFIGURE) {
		json_data(
			response, MOD_EMTR, OK_STR,
			json_sprintf(
				data_str,
				"\"Address\" : \"0x%04X\", "
				"\"Mode\" : \"%s\", "
				"\"CounterActive\" : %d, "
				"\"CounterApparent\" : %d, "
				"\"ReadInterval\" : %d, "
				
				"\"OverCurrentLimit\" : %d, "
				"\"OverPowerLimit\" : %d, "
				"\"OverFrequencyLimit\" : %d, "
				"\"UnderFrequencyLimit\" : %d, "
				"\"OverTemperatureLimit\" : %d, "
				"\"UnderTemperatureLimit\" : %d, "
				"\"VoltageSagLimit\" : %d, "
				"\"VoltageSurgeLimit\" : %d, "
				"\"OverCurrentHold\" : %d, "
				"\"OverPowerHold\" : %d, "
				"\"OverFrequencyHold\" : %d, "
				"\"UnderFrequencyHold\" : %d, "
				"\"OverTemperatureHold\" : %d, "
				"\"UnderTemperatureHold\" : %d, "
				"\"EventEnable\" : %d, "
				"\"EventMaskCritical\" : %d, "
				"\"EventMaskStandard\" : %d, "
				"\"EventTest\" : %d, "
				"\"EventClear\" : %d",
				emtr_address(),
				emtr_mode_str(emtr_current_mode),
				emtr_counter_active(),
				emtr_counter_apparent(),
				emtr_read_interval,
				
				emtr_registers.event->over_current_limit,
				emtr_registers.event->over_power_limit,
				emtr_registers.event->over_frequency_limit,
				emtr_registers.event->under_frequency_limit,
				emtr_registers.event->over_temperature_limit,
				emtr_registers.event->under_temperature_limit,
				emtr_registers.event->voltage_sag_limit,
				emtr_registers.event->voltage_surge_limit,
				emtr_registers.event->over_current_hold,
				emtr_registers.event->over_power_hold,
				emtr_registers.event->over_frequency_hold,
				emtr_registers.event->under_frequency_hold,
				emtr_registers.event->over_temperature_hold,
				emtr_registers.event->under_temperature_hold,
				emtr_registers.event->event_enable,
				emtr_registers.event->event_mask_critical,
				emtr_registers.event->event_mask_standard,
				emtr_registers.event->event_test,
				emtr_registers.event->event_clear
			),
			NULL
		);
		setTimeout(emtr_events_read, NULL, 1500);
	} else {
		json_data(
			response, MOD_EMTR, OK_STR,
			json_sprintf(
				data_str,
				"\"Address\" : \"0x%04X\", "
				"\"Mode\" : \"%s\", "
				"\"CounterActive\" : %d, "
				"\"CounterApparent\" : %d, "
				"\"ReadInterval\" : %d",
				emtr_address(),
				emtr_mode_str(emtr_current_mode),
				emtr_counter_active(),
				emtr_counter_apparent(),
				emtr_read_interval
			),
			NULL
		);
	}
	
	emtr_start_read();
}
static void FUNCTION_ATTRIBUTE
http_callback_login(char * response)
{
    if(request != NULL)
    {
        pd_free(request);
        request = NULL;
    }
    
    if(response == NULL)
    {
        device_login_callback(PANDO_LOGIN_FAIL);
        return;
    }
    
    pd_printf("response=%s\n(end)\n", response);
	
	uint16_t response_len = pd_strlen(response) + 1;
    char* login_response = (char*)pd_malloc(response_len);
	pd_memset(login_response, 0, response_len);
	pd_memcpy(login_response, response, response_len);
	
    struct jsonparse_state json_state;
    jsonparse_setup(&json_state, login_response, pd_strlen(login_response));
    int code;
    char message[MSG_BUF_LEN];
    char access_token[ACCESS_TOKEN_LEN*2 + 16];
    char access_addr[KEY_BUF_LEN];

    access_token[ACCESS_TOKEN_LEN*2] = '\0';
    int type;
    while ((type = jsonparse_next(&json_state)) != 0)
    {
        if (type == JSON_TYPE_PAIR_NAME) 
        {
            if(jsonparse_strcmp_value(&json_state, "code") == 0) 
            {
                jsonparse_next(&json_state);
                jsonparse_next(&json_state);
                code = jsonparse_get_value_as_int(&json_state);
            }
            else if(jsonparse_strcmp_value(&json_state, "message") == 0)
            {
                jsonparse_next(&json_state);
                jsonparse_next(&json_state);
                jsonparse_copy_value(&json_state, message, MSG_BUF_LEN);
            }
            else if(jsonparse_strcmp_value(&json_state, "data") == 0)
            {
                while((type = jsonparse_next(&json_state)) != 0 && json_state.depth > 1)
                {
                    if(type == JSON_TYPE_PAIR_NAME)
                    {
                        if(jsonparse_strcmp_value(&json_state, "access_token") == 0) 
                        {
                            jsonparse_next(&json_state);
                            jsonparse_next(&json_state);
                            jsonparse_copy_value(&json_state, access_token, ACCESS_TOKEN_LEN*2 + 16);
                        }
                        else if(jsonparse_strcmp_value(&json_state, "access_addr") == 0)
                        {
                            jsonparse_next(&json_state);
                            jsonparse_next(&json_state);
                            jsonparse_copy_value(&json_state, access_addr, KEY_BUF_LEN);
                        }
                    }
                }
            }
        }
    }

    if(login_response != NULL)
    {
    	pd_free(login_response);
    }

    if(code != 0)
    {
    	pd_printf("device login failed: %s\n", message);
        if(device_login_callback != NULL) 
        {
            device_login_callback(PANDO_LOGIN_FAIL);
        }
        return;
    }

    hex2bin(pando_device_token, access_token);


    pd_printf("device login success, access_addr : %s\n", access_addr);

    pando_data_set(DATANAME_ACCESS_ADDR, access_addr);
    pando_data_set(DATANAME_ACCESS_TOKEN, access_token);
    if(device_login_callback != NULL) 
    {
        device_login_callback(PANDO_LOGIN_OK);
    }
}