option to reset to factory firmware, fix #40

Author: kglowacki

bin/deploy_ota.sh

@@ -9,7 +9,8 @@ DEST_FOLDER=s3://openairproject.com/ota
 
 printf "$1|$1/sensor-esp32.bin|" > $INDEX_FILE
 
-cat build/sensor-esp32.bin | openssl dgst -sha256 >> $INDEX_FILE
+cat build/sensor-esp32.bin | openssl dgst -sha256 -binary | xxd -p -c 100 >> $INDEX_FILE
+cat $INDEX_FILE
 
 aws s3 cp build/sensor-esp32.bin $DEST_FOLDER/$1/sensor-esp32.bin --profile oap
 aws s3 cp $INDEX_FILE $DEST_FOLDER/index.txt --profile oap

components/oap-hw-ext/ctrl_btn.c

@@ -30,93 +30,80 @@
 #include "oap_common.h"
 #include "ctrl_btn.h"
 #include "esp_log.h"
+#include "esp_err.h"
+#include "driver/gpio.h"
+#include "freertos/queue.h"
 
 #define ESP_INTR_FLAG_DEFAULT 0
+#define TAG "btn"
 
-static QueueHandle_t gpio_evt_queue = NULL;
-static QueueHandle_t btn_events = NULL;
+typedef struct {
+	uint8_t gpio_num;
+	uint32_t timestamp;
+} gpio_event_t;
 
+static QueueHandle_t gpio_evt_queue;
+static uint32_t last_click = 0;
+static btn_callback_f _callback = NULL;
 
 static void IRAM_ATTR gpio_isr_handler(void* arg)
 {
-    uint32_t gpio_num = (uint32_t) arg;
-    xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
+	uint32_t t = millis();
+	/*
+	 * TODO is there a way to programmatically eliminate flickering?
+	 */
+	if (t - last_click < 80) return;
+	last_click = t;
+    gpio_event_t gpio_evt = {
+    	.gpio_num = (uint8_t)(uint32_t)arg,
+		.timestamp = t
+    };
+    xQueueSendFromISR(gpio_evt_queue, &gpio_evt, NULL);
 }
 
-static long int now() {
-	struct timeval tv;
-	gettimeofday(&tv, NULL);
-	return tv.tv_sec * 1000 + tv.tv_usec / 1000;
+static void gpio_watchdog_task() {
+	gpio_event_t gpio_evt;
+	int count = 0;
+	uint32_t first_click = 0;
+
+	while(1) {
+		if (xQueueReceive(gpio_evt_queue, &gpio_evt, 1000)) {
+			_callback(SINGLE_CLICK);
+			//20 sec to perform the action
+			if (!first_click || gpio_evt.timestamp - first_click > 20000) {
+				first_click = gpio_evt.timestamp;
+				count = 0;
+			}
+			count++;
+			ESP_LOGD(TAG, "click gpio[%d] [%d in sequence]",gpio_evt.gpio_num, count);
+
+			//due to flickering we cannot precisely count all clicks anyway
+			if (count == 10) {
+				_callback(MANY_CLICKS);
+			}
+			if (count >= 20) {
+				_callback(TOO_MANY_CLICKS);
+				first_click=0;
+				count=0;
+			}
+		}
+	}
 }
 
-static uint8_t gpio_to_index[40] = {-1};
-
-static void btn_task()
-{
-    uint32_t io_num;
-    uint8_t level[40] = {0};
-    long int time = now();
-    long int _time;
-
-
-    for(;;) {
-        if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) {
-
-        	//debounce
-        	_time = now();
-        	if (_time - time > 50 || io_num >= 40) {
-        		btn_event event = {
-        			.index = gpio_to_index[io_num],
-        			.gpio = io_num,
-					.level= gpio_get_level(io_num)
-        		};
-
-        		if (level[event.gpio] == event.level) continue;
-
-        		time = _time;
-        		level[event.gpio] = event.level;
-        		xQueueSend(btn_events, &event, 500);
-        	}
-        }
-    }
+esp_err_t btn_configure(btn_callback_f callback) {
+	_callback = callback;
+	gpio_evt_queue = xQueueCreate(10, sizeof(gpio_event_t));
+	gpio_pad_select_gpio(CONFIG_OAP_BTN_0_PIN);
+	gpio_set_direction(CONFIG_OAP_BTN_0_PIN, GPIO_MODE_INPUT);
+	gpio_set_pull_mode(CONFIG_OAP_BTN_0_PIN, GPIO_PULLDOWN_ONLY);
+	gpio_set_intr_type(CONFIG_OAP_BTN_0_PIN, GPIO_INTR_POSEDGE);
+	gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
+	gpio_isr_handler_add(CONFIG_OAP_BTN_0_PIN, gpio_isr_handler, (void*) CONFIG_OAP_BTN_0_PIN);
+	xTaskCreate((TaskFunction_t)gpio_watchdog_task, "gpio_watchdog_task", 1024*2, NULL, DEFAULT_TASK_PRIORITY+2, NULL);
+	return ESP_OK; //TODO handle errors
 }
 
-
-QueueHandle_t btn_init(gpio_num_t *btn_gpio, uint8_t num_of_btns)
-{
-	btn_events = xQueueCreate(1, sizeof(btn_event));
-    gpio_config_t io_conf;
-
-    //interrupt of ...
-    io_conf.intr_type = GPIO_INTR_ANYEDGE;
-    //bit mask of the pins,
-    io_conf.pin_bit_mask = 0;
-    //set as input mode
-    io_conf.mode = GPIO_MODE_INPUT;
-    //set pull-up mode
-    io_conf.pull_up_en = 0;
-    io_conf.pull_down_en = 1;
-
-    for (int n = 0; n < num_of_btns; n++) {
-    	io_conf.pin_bit_mask |=  (uint64_t)(((uint64_t)1)<<((uint64_t)(btn_gpio[n])));
-    }
-
-    gpio_config(&io_conf);
-
-    //create a queue to handle gpio event from isr
-    gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));
-    //start gpio task
-    xTaskCreate(btn_task, "btn_task", 2048, NULL, DEFAULT_TASK_PRIORITY, NULL);
-
-    //install gpio isr service
-    gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
-    //hook isr handler for specific gpio pin
-    for (int n = 0; n < num_of_btns; n++) {
-    	gpio_to_index[btn_gpio[n]] = n;
-    	gpio_isr_handler_add(btn_gpio[n], gpio_isr_handler, (void*) btn_gpio[n]);
-    }
-
-    return btn_events;
+bool is_ap_mode_pressed() {
+	return gpio_get_level(CONFIG_OAP_BTN_0_PIN);
 }
 
-

components/oap-hw-ext/include/ctrl_btn.h

@@ -23,15 +23,14 @@
 #ifndef MAIN_BTN_H_
 #define MAIN_BTN_H_
 
-#include "freertos/queue.h"
-#include "driver/gpio.h"
+typedef enum {
+	SINGLE_CLICK,
+	MANY_CLICKS,
+	TOO_MANY_CLICKS
+} btn_action_t;
+typedef void(*btn_callback_f)(btn_action_t);
 
-typedef struct {
-	uint8_t 	index;
-	gpio_num_t 	gpio;
-	uint8_t 	level;
-} btn_event;
-
-xQueueHandle btn_init(gpio_num_t* btns_gpio, uint8_t num_of_btns);
+bool is_ap_mode_pressed();
+esp_err_t btn_configure(btn_callback_f callback);
 
 #endif /* MAIN_BTN_H_ */

components/oap-hw-ext/rgb_led.c

@@ -39,7 +39,7 @@ static const char* TAG = "rgbled";
 static xQueueHandle cmd_queue;
 static gpio_num_t led_gpio[] = {CONFIG_OAP_LED_R_PIN,CONFIG_OAP_LED_G_PIN,CONFIG_OAP_LED_B_PIN};
 
-#define DEFAULT_FREQ 1500
+#define DEFAULT_FREQ 1000
 
 static ledc_mode_t speed_mode = LEDC_HIGH_SPEED_MODE;
 

components/oap-ota/include/ota.h

@@ -31,5 +31,6 @@
 #define OAP_OTA_INDEX_URI 		CONFIG_OAP_OTA_INDEX_URI
 
 void start_ota_task(cJSON* user_ota_config);
+void reset_to_factory_partition();
 
 #endif /* COMPONENTS_OTA_INCLUDE_OTA_H_ */

components/oap-ota/ota.c

@@ -71,6 +71,17 @@ static int is_white_char(int ch) {
 	return ch == '\n' || ch == '\r' || ch == '\t';
 }
 
+void reset_to_factory_partition() {
+	ESP_LOGW(TAG, "RESET TO FACTORY");
+	const esp_partition_t *factory = esp_partition_find_first(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_APP_FACTORY, NULL);
+	if (factory) {
+		esp_ota_set_boot_partition(factory);
+		oap_reboot();
+	} else {
+		ESP_LOGE(TAG, "no factory partition?");
+	}
+}
+
 esp_err_t parse_ota_info(ota_info_t* ota_info, char* line, int len) {
 	if (len <= 0) return OAP_OTA_ERR_EMPTY_RESPONSE;
 	char* ver = NULL; char* file = NULL; char* sha = NULL;

main/main.c

@@ -50,6 +50,8 @@
 #include "oap_data.h"
 #include "server_cpanel.h"
 
+#define ESP_INTR_FLAG_DEFAULT 0
+
 static const char *TAG = "app";
 
 
@@ -69,26 +71,24 @@ static led_cmd_t ledc_state = {
 	.color = {.v = {0,0,1}} //initial color (when no samples collected)
 };
 
-static void ledc_set() {
+static void ledc_update() {
 	xQueueSend(ledc_queue, &ledc_state, 100);
 }
 
 static void ledc_set_mode(led_mode_t mode) {
 	ledc_state.mode = mode;
-	ledc_set();
 }
 
-static void ledc_set_color(led_mode_t mode, float r, float g, float b) {
+static void ledc_set_color(float r, float g, float b) {
 	ledc_state.color.v[0] = r;
 	ledc_state.color.v[1] = g;
 	ledc_state.color.v[2] = b;
-	ledc_set_mode(mode);
 }
 
 static void ledc_init() {
 	ledc_queue = xQueueCreate(10, sizeof(led_cmd_t));
 	led_init(oap_sensor_config.led, ledc_queue);
-	ledc_set();
+	ledc_update();
 }
 
 
@@ -121,6 +121,7 @@ static void pm_meter_output_handler(pm_meter_event_t event, void* data) {
 	case PM_METER_START:
 		ESP_LOGI(TAG, "start measurement");
 		ledc_set_mode(LED_PULSE);
+		ledc_update();
 		break;
 	case PM_METER_RESULT:
 		ESP_LOGI(TAG, "finished measurement");
@@ -302,7 +303,9 @@ static void publish_loop() {
 			log_task_stack(TAG);
 			float aqi = fminf(pm_data_pair.pm_data[0].pm2_5 / 100.0, 1.0);
 			//ESP_LOGI(TAG, "AQI=%f",aqi);
-			ledc_set_color(LED_SET, aqi,(1-aqi), 0);
+			ledc_set_color(aqi,(1-aqi), 0);
+			ledc_set_mode(LED_SET);
+			ledc_update();
 
 			oap_measurement_t meas = {
 				.pm = &pm_data_pair.pm_data[0],
@@ -343,29 +346,40 @@ void publishers_init() {
 	}
 }
 
-static void configure_ap_mode_btn() {
-	gpio_pad_select_gpio(CONFIG_OAP_BTN_0_PIN);
-	gpio_set_direction(CONFIG_OAP_BTN_0_PIN, GPIO_MODE_INPUT);
-	gpio_set_pull_mode(CONFIG_OAP_BTN_0_PIN, GPIO_PULLDOWN_ONLY);
-}
 
-static int is_ap_mode_pressed() {
-	return gpio_get_level(CONFIG_OAP_BTN_0_PIN);
+static void btn_handler(btn_action_t action) {
+	switch (action) {
+		case MANY_CLICKS :
+			ESP_LOGW(TAG, "about to perform factory reset!");
+			ledc_set_mode(LED_BLINK);
+			ledc_update();
+			break;
+		case TOO_MANY_CLICKS :
+			reset_to_factory_partition();
+			break;
+		default:
+			break;
+	}
 }
 
 void app_main() {
+	//silence annoying logs
+	esp_log_level_set("ledc", ESP_LOG_INFO);
+	esp_log_level_set("nvs", ESP_LOG_INFO);
+	esp_log_level_set("tcpip_adapter", ESP_LOG_INFO);
+
+	//a sec to start flashing
 	delay(1000);
 	ESP_LOGI(TAG,"starting app... firmware %s", oap_version_str());
 
 	//130kb is a nice cap to test against alloc fails
 	//reduce_heap_size_to(130000);
 	storage_init();
 
-	ESP_LOGD(TAG, "retrieve sensor config");
 	oap_sensor_config = sensor_config_from_json(cJSON_GetObjectItem(storage_get_config("sensor"), "config"));
 
 	//wifi/mongoose requires plenty of mem, start it here
-	configure_ap_mode_btn();
+	btn_configure(&btn_handler);
 	wifi_configure(is_ap_mode_pressed() ? NULL : storage_get_config("wifi"), CONFIG_OAP_CONTROL_PANEL ? cpanel_wifi_handler : NULL);
 	wifi_boot();
 	start_ota_task(storage_get_config("ota"));