示例#1
0
LOCAL void ICACHE_FLASH_ATTR finger_params_ready(finger_packet *packet) {
	char response[WEBSERVER_MAX_RESPONSE_LEN];
	char data_str[WEBSERVER_MAX_VALUE];
	
	json_data(
		response, MOD_FINGER, OK_STR,
		json_sprintf(
			data_str,
			"\"Address\" : \"0x%08X\", "
			"\"DBSize\" : %d, "
			"\"DBStored\" : %d, "
			"\"FirstFree\" : %d, "
			"\"SecurityLevel\" : %d, "
			"\"Mode\" : \"%s\"",
			finger_address(), 
			finger_db_size(),
			finger_db_stored(),
			finger_first_free_id(),
			finger_security_level(),
			finger_mode_str(finger_current_mode)
		),
		NULL
	);
	
	user_event_raise(FINGER_URL, response);
}
示例#2
0
LOCAL void ICACHE_FLASH_ATTR finger_find_done(finger_packet *packet) {
	if (packet->data[0] != FINGER_OK) {
		finger_default(packet);
		finger_start_read();
		return;
	}
	
	uint16 id = packet->data[1]*256 + packet->data[2];
	uint16 score = packet->data[3]*256 + packet->data[4];
	
	char response[WEBSERVER_MAX_VALUE];
	char data[WEBSERVER_MAX_VALUE];
	json_status(
		response, MOD_FINGER, "Match found",
		json_sprintf(
			data,
			"\"Match\" : {\"ID\" : %d, \"Score\" : %d}",
			id,
			score
		)
	);
	
#if FINGER_DEBUG
	debug("FINGER: Match: ID = %d, Score = %d\n", id, score);
#endif
	
	user_event_raise(FINGER_URL, response);
	finger_start_read();
}
示例#3
0
LOCAL void ICACHE_FLASH_ATTR finger_save_done(finger_packet *packet) {
	finger_current_mode = FINGER_READ;
	
	if (packet->data[0] != FINGER_OK) {
		finger_default(packet);
		finger_frech_params();
		finger_start_read();
		return;
	}
	
	char response[WEBSERVER_MAX_VALUE];
	char data[WEBSERVER_MAX_VALUE];
	json_status(
		response, MOD_FINGER, 
		"New fingerprint stored",
		json_sprintf(data, "\"ID\" : %d", finger_first_free_id())
	);
	
#if FINGER_DEBUG
	debug("FINGER: Stored: ID = %d\n", finger_first_free_id());
#endif
	
	user_event_raise(FINGER_URL, response);
	finger_frech_params();
	finger_start_read();
}
示例#4
0
LOCAL void ICACHE_FLASH_ATTR mod_tc_mk2_read(i2c_config *config, char *response, bool poll) {
	poll = true;
	
	tc_config_data *config_data = (tc_config_data *)config->data;
	
	char address_str[MAX_I2C_ADDRESS];
	json_i2c_address(address_str, config->address);
	
	i2c_status status = tc_read(config);
	if (status == I2C_OK) {
		char poll_str[WEBSERVER_MAX_VALUE];
		if (poll) {
			json_poll_str(poll_str, tc_refresh / 1000, tc_each, tc_threshold);
		} else {
			poll_str[0] = '\0';
		}
		
		char data_str[WEBSERVER_MAX_VALUE];
		json_data(
			response, MOD_TC_MK2, OK_STR,
			json_sprintf(
				data_str,
				"\"Temperature\" : %s %s",
				config_data->temperature_str,
				poll_str
			),
			address_str
		);
	} else {
		json_error(response, MOD_TC_MK2, i2c_status_str(status), address_str);
	}
}
示例#5
0
LOCAL void ICACHE_FLASH_ATTR dimmer_response(i2c_config *config, char *response, bool poll) {
	dimmer_config_data *config_data = (dimmer_config_data *)config->data;
	
	char address_str[MAX_I2C_ADDRESS];
	json_i2c_address(address_str, config->address);
	
	char poll_str[WEBSERVER_MAX_VALUE];
	if (poll) {
		json_poll_str(poll_str, dimmer_refresh / 1000, dimmer_each, dimmer_threshold);
	} else {
		poll_str[0] = '\0';
	}
		
	char data_str[WEBSERVER_MAX_VALUE];
	json_data(
		response, DIMMER_STR, OK_STR,
		json_sprintf(
			data_str,
			"\"Relay\" : %d, "
			"\"Brightness\" : %d,"
			"\"Current\" : %d"
			"%s",
			config_data->relay, 
			config_data->brightness,
			config_data->current,
			poll_str
		),
		address_str
	);
}
/* Make response */
LOCAL void ICACHE_FLASH_ATTR mb_pcd8544_set_response(char *response, bool is_fault, uint8 req_type) {
	char data_str[WEBSERVER_MAX_RESPONSE_LEN];
	char full_device_name[USER_CONFIG_USER_SIZE];
	
	mb_make_full_device_name(full_device_name, MB_PCD8544_DEVICE, USER_CONFIG_USER_SIZE);
	
	MB_PCD8544_DEBUG("PCD8544:Resp.prep:%d;isFault:%d:\n", req_type, is_fault)
	
	// Sensor fault
	if (is_fault) {
		json_error(response, full_device_name, DEVICE_STATUS_FAULT, NULL);
	}
	// POST request - status & config only
	else if (req_type == MB_REQTYPE_POST) {
		json_status(response, full_device_name, DEVICE_STATUS_OK, 
			json_sprintf(
				data_str, 
				"\"Config\" : {"
					"\"Reset_pin\": %d,"
					"\"Sce_pin\":%d,"
					"\"Dc_pin\": %d,"
					"\"Sdin_pin\": %d,"
					"\"Sclk_pin\": %d"
				"}",
				mb_p_pcd8544_config->resetPin,
				mb_p_pcd8544_config->scePin,
				mb_p_pcd8544_config->dcPin,
				mb_p_pcd8544_config->sdinPin,
				mb_p_pcd8544_config->sclkPin
			)
		);

	// normal event measurement
	} else {
		json_data(
			response, full_device_name, DEVICE_STATUS_OK, 
				json_sprintf(data_str,
					"\"pcd8544\": {"
					"}"
				),
				NULL
		);
	}
}
示例#7
0
LOCAL void ICACHE_FLASH_ATTR user_relay_state(char *response) {
	char data_str[WEBSERVER_MAX_VALUE];
	json_data(
		response, ESP8266, OK_STR,
		json_sprintf(
			data_str,
			"\"Relay\" : %d",
			relay_state
		),
		NULL
	);
}
示例#8
0
char ICACHE_FLASH_ATTR *json_data(char *buffer, const char *device, const char *status, const char *data, const char *extra) {
	uint32 extra_len = extra == NULL ? 0 : os_strlen(extra);
	char data_buff[os_strlen(data) + extra_len + 20];
	return json_status(
		buffer, device, status, 
		json_sprintf(
			data_buff, 
			"\"Data\" : {%s}%s%s", 
			data,
			extra_len == 0 ? "" : ", ",
			extra_len == 0 ? "" : extra
		)
	);
}
示例#9
0
void ICACHE_FLASH_ATTR user_event_system_timer() {
	char status[WEBSERVER_MAX_RESPONSE_LEN];
	char data[WEBSERVER_MAX_RESPONSE_LEN];
	user_event_raise(
		NULL, 
		json_status(
			status, ESP8266, "SysTimer", 
			json_sprintf(
				data,
				"\"Timer\": %d",
				system_get_time()
			)
		)
	);
}
示例#10
0
LOCAL void ICACHE_FLASH_ATTR user_switch1_state(char *response) {
    char data_str[WEBSERVER_MAX_VALUE];
    json_data(
        response, SWITCH1_STR, OK_STR,
        json_sprintf(
            data_str,
            "\"Relay\" : %d, "
            "\"Switch\" : %d, "
            "\"Preference\" : %d ",
            switch1_hardware[0].state,
            switch1_hardware[1].state,
            switch1_hardware[1].preference
        ),
        NULL
    );
}
示例#11
0
LOCAL void ICACHE_FLASH_ATTR button_set_response(char *state) {
	char response[WEBSERVER_MAX_VALUE];
	debug("BUTTON: %s\n", state);
	
	char data[WEBSERVER_MAX_VALUE];
	json_data(
		response, ESP8266, OK_STR,
		json_sprintf(
			data,
			"\"Button\" : \"%s\"",
			state
		),
		NULL
	);
	
	user_event_raise(BUTTON_URL, response);
}
示例#12
0
void ICACHE_FLASH_ATTR user_event_server_disconnected(const char *msg) {
	char data[WEBSERVER_MAX_VALUE];
	char buff[WEBSERVER_MAX_VALUE];
	user_websocket_event(
		USER_CONFIG_IOT_URL, 
		json_data(
			data, ESP8266, DISCONNECTED, 
			json_sprintf(
				buff, 
				"\"Message\": \"%s\"", 
				msg
			),
			NULL
		),
		NULL
	);
}
示例#13
0
void ICACHE_FLASH_ATTR wifi_scan_get_result(char *response) {
	if (wifi_scan_in_progress) {
		webserver_set_status(0);
		return;
	}
	
	if (wifi_scan_ap_count == 0 || wifi_scan_result == NULL) {
		if (wifi_scan_start()) {
			webserver_set_status(0);
			return;
		}
		
		webserver_set_status(200);
		json_error(response, ESP8266, "Can not start scan", NULL);
		return;
	}
	
	webserver_set_status(200);
	
	char result[WEBSERVER_MAX_VALUE*wifi_scan_ap_count];
	os_memset(result, '\0', sizeof(result));
	
	uint8 i=0;
	for (i=0; i<wifi_scan_ap_count; i++) {
		os_sprintf(
			result + os_strlen(result), 
			"%s{\"SSID\" : \"%s\", \"Strength\" : %d, \"Mode\" : \"%s\"}", 
			i > 0 ? ", " : "",
			wifi_scan_result[i]->ssid, 
			wifi_scan_result[i]->rssi, 
			wifi_auth_mode_str(wifi_scan_result[i]->authmode)
		);
	}
	
	char data_str[WEBSERVER_MAX_VALUE*wifi_scan_ap_count];
	json_data(
		response, ESP8266, OK_STR,
		json_sprintf(
			data_str,
			"\"WiFi\" : [%s]",
			result
		),
		NULL
	);
}
示例#14
0
LOCAL void ICACHE_FLASH_ATTR user_switch1_state(char *response) {
	char data_str[WEBSERVER_MAX_VALUE];
	
	uint8 i;
	for (i=0; i<SWITCH_COUNT; i++) {
		if (switch1_hardware[i].type == SWITCH1_SWITCH) {
			switch1_hardware[i].state = GPIO_INPUT_GET(GPIO_ID_PIN(switch1_hardware[i].gpio.gpio_id));
		}
	}
	
	json_data(
		response, SWITCH1_STR, OK_STR,
		json_sprintf(
			data_str,
			"\"Relay\" : %d, "
			"\"Switch\" : %d ",
			switch1_hardware[0].state,
			switch1_hardware[1].state
		),
		NULL
	);
}
示例#15
0
LOCAL void ICACHE_FLASH_ATTR adc_read(char *response, bool poll) {
	char data[WEBSERVER_MAX_VALUE];
	char poll_str[WEBSERVER_MAX_VALUE];
	
	poll = true;
	state = system_adc_read();
	
	if (poll) {
		json_poll_str(poll_str, adc_refresh / 1000, adc_each, adc_threshold);
	} else {
		poll_str[0] = '\0';
	}
	
	json_data(
		response, ESP8266, OK_STR, 
		json_sprintf(
			data,
			"\"ADC\" : {\"Value\" : %d %s}",
			state,
			poll_str
		),
		NULL
	);
}
示例#16
0
void ICACHE_FLASH_ATTR mod_led_8x8_rgb_handler(
	struct espconn *pConnection, 
	request_method method, 
	char *url, 
	char *data, 
	uint16 data_len, 
	uint32 content_len, 
	char *response,
	uint16 response_len
) {
	
	
	if (mod_led_8x8_text == NULL) {
		mod_led_8x8_text = (char *)os_zalloc(MOD_LED_8x8_RGB_MAX_TEXT);
	}
	
	if (method == POST && data != NULL && data_len != 0) {
		if (led_8x8_rgb_busy()) {
			json_error(response, MOD_LED8x8RGB, BUSY_STR, NULL);
			return;
		}
		
		if (mod_led_8x8_rgb_parse(data, data_len)) {
			if (!led_8x8_rgb_set_dimensions(mod_led_8x8_cols, mod_led_8x8_rows)) {
				json_error(response, MOD_LED8x8RGB, "Dimensions can not be set", NULL);
				return;
			}
			
			mod_led_8x8_rgb_preferences_set();
		}
		
		if (
			!led_8x8_rgb_scroll(
				mod_led_8x8_r, 
				mod_led_8x8_g, 
				mod_led_8x8_b, 
				mod_led_8x8_text, 
				MOD_LED_8x8_RGB_MAX_SPEED - mod_led_8x8_speed + 1, 
				mod_led_8x8_rgb_scroll_done
			)
		) {
			json_error(response, MOD_LED8x8RGB, BUSY_STR, NULL);
			return;
		}
	}
	
	char data_str[WEBSERVER_MAX_VALUE * 2];
	char *escaped = json_escape_str(mod_led_8x8_text, MOD_LED_8x8_RGB_MAX_TEXT);
	
	json_data(
		response, MOD_LED8x8RGB, OK_STR,
		json_sprintf(
			data_str,
			"\"cols\" : %d, "
			"\"rows\" : %d, "
			"\"Speed\" : %d, "
			"\"R\" : %d, "
			"\"G\" : %d, "
			"\"B\" : %d, "
			"\"Text\" : \"%s\"",
			led_8x8_rgb_get_cols(),
			led_8x8_rgb_get_rows(),
			mod_led_8x8_speed,
			mod_led_8x8_r,
			mod_led_8x8_g,
			mod_led_8x8_b,
			escaped
		),
		NULL
	);
	
	os_free(escaped);
}
示例#17
0
void ICACHE_FLASH_ATTR mod_irda_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(MOD_IRDA, MOD_IRDA_URL, irda_init, url, response);
	if (config == NULL) {
		return;
	}
	
	irda_config_data *config_data = (irda_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, "Mode") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					if (jsonparse_strcmp_value(&parser, "SIRC") == 0) {
						config_data->mode = 1;
					} else {
						config_data->mode = 0;
					}
				} else if (jsonparse_strcmp_value(&parser, "Device") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					config_data->device = jsonparse_get_value_as_int(&parser);
				} else if (jsonparse_strcmp_value(&parser, "Command") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					config_data->command = jsonparse_get_value_as_int(&parser);
				}
			}
		}
		
		status = irda_set(config);
	}
	
	char address_str[MAX_I2C_ADDRESS];
	json_i2c_address(address_str, config->address);
	
	if (status == I2C_OK) {
		char data_str[WEBSERVER_MAX_VALUE];
		json_data(
			response, MOD_IRDA, OK_STR,
			json_sprintf(
				data_str,
				"\"Mode\" : \"%s\", "
				"\"Device\" : %d, "
				"\"Command\" : %d ",
				irda_mode_str(config_data->mode), 
				config_data->device,
				config_data->command
			),
			address_str
		);
	} else {
		json_error(response, MOD_IRDA, i2c_status_str(status), address_str);
	}
}
示例#18
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();
}
示例#19
0
LOCAL void ICACHE_FLASH_ATTR emtr_read_done(emtr_packet *packet) {
	LOCAL emtr_output_registers *registers = NULL;
	LOCAL uint32 time = 0;
	LOCAL uint32 interval = 0;
	LOCAL uint32 now = 0;
	
	now = system_get_time();
	interval = (time != 0) ? 
		(now - time) / 1000
		: 
		0
	;
	time = now;
	
	if (registers == NULL) {
		registers = (emtr_output_registers *)os_zalloc(sizeof(emtr_output_registers));
	}
	
	emtr_parse_output(packet, registers);
	
	char event_str[20];
	os_memset(event_str, 0, sizeof(event_str));
	
	char response[WEBSERVER_MAX_RESPONSE_LEN];
	char data_str[WEBSERVER_MAX_RESPONSE_LEN];
	json_data(
		response, MOD_EMTR, OK_STR,
		json_sprintf(
			data_str,
			"\"Address\" : \"0x%04X\", "
			"\"CounterActive\" : %d, "
			"\"CounterApparent\" : %d, "
			"\"Interval\" : %d, "
			
			"\"CurrentRMS\" : %d, "
			"\"VoltageRMS\" : %d, "
			"\"ActivePower\" : %d, "
			"\"ReactivePower\" : %d, "
			"\"ApparentPower\" : %d, "
			"\"PowerFactor\" : %d, "
			"\"LineFrequency\" : %d, "
			"\"ThermistorVoltage\" : %d, "
			"\"EventFlag\" : %d, "
			"\"SystemStatus\" : \"0x%04X\"",
			emtr_address(),
			emtr_counter_active(),
			emtr_counter_apparent(),
			interval,
			
			registers->current_rms,
			registers->voltage_rms,
			registers->active_power,
			registers->reactive_power,
			registers->apparent_power,
			registers->power_factor,
			registers->line_frequency,
			registers->thermistor_voltage,
			registers->event_flag,
			registers->system_status
		),
		NULL
	);
	
	emtr_counter_add(
		registers->active_power * interval / 1000, 
		registers->apparent_power * interval / 1000
	);
	
	user_event_raise(EMTR_URL, response);
	emtr_start_read();
	
	if (registers->event_flag != 0) {
		emtr_clear_event(registers->event_flag, NULL);
	}
}
示例#20
0
void ICACHE_FLASH_ATTR mod_rgb_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_config *config = i2c_init_handler(MOD_RGB, MOD_RGB_URL, rgb_init, url, response);
	if (config == NULL) {
		return;
	}
	
	rgb_config_data *config_data = (rgb_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, "R") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					config_data->red = jsonparse_get_value_as_int(&parser);
				} else if (jsonparse_strcmp_value(&parser, "G") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					config_data->green = jsonparse_get_value_as_int(&parser);
				} else if (jsonparse_strcmp_value(&parser, "B") == 0) {
					jsonparse_next(&parser);
					jsonparse_next(&parser);
					config_data->blue = jsonparse_get_value_as_int(&parser);
				}
			}
		}
	}
	
	char address_str[MAX_I2C_ADDRESS];
	json_i2c_address(address_str, config->address);
	
	status = rgb_set(config);
	if (status == I2C_OK) {
		char data_str[WEBSERVER_MAX_VALUE];
		json_data(
			response, MOD_RGB, OK_STR,
			json_sprintf(
				data_str,
				"\"R\" : %d, \"G\" : %d, \"B\" : %d",
				config_data->red, 
				config_data->green, 
				config_data->blue
			),
			address_str
		);
	} else {
		json_error(response, MOD_RGB, i2c_status_str(status), address_str);
	}
}