co2-firmware/main/CO2_Sense.c

#include "CO2_Sense.h"
#include <string.h>
#include "configuration.h"
#include "freertos/FreeRTOS.h"
#include "freertos/portmacro.h"
#include "freertos/task.h"
#include <stdio.h>
#include "hal/gpio_types.h"
#include "nvs_flash.h"

#include "lwip/err.h"
#include "lwip/sys.h"

#include "esp_log.h"
#include "esp_sleep.h"
#include "esp_pm.h"
#include "driver/gpio.h"
#include "driver/i2c.h"

#include "ledController.h"
#include "power_inout.h"
#include "scd4x_i2c.h"
#include "scd4x_util.h"
#include "sdkconfig.h"
#include "sensirion_i2c_hal.h"
#include "scd4x_data.h"
#include "BTlib_nimble.h"
#include "MMC56x3.h"

#define TAG "MAIN"

void app_main(void){
	init_nvs();
	
	// setup GPIOs
	gpio_config_t VBAT_OK_c = {
		GPIO_NUM_3,
		GPIO_MODE_INPUT,
		GPIO_PULLUP_DISABLE,
		GPIO_PULLDOWN_DISABLE,
		GPIO_INTR_DISABLE,
	};
	ESP_ERROR_CHECK(gpio_config(&VBAT_OK_c));
	
	esp_pm_config_esp32c3_t pm_config = {
		.max_freq_mhz = 80,
		.min_freq_mhz = 40,
		.light_sleep_enable = true, // enable light sleep
	};
	ESP_ERROR_CHECK(esp_pm_configure(&pm_config));

	configuration_data_t* conf = malloc(sizeof(configuration_data_t));
	init_conf_from_nvs(conf);
	
	// init LEDs driver	
	init_led_driver(conf->leds, conf->led_nb);
	
	// init BLE
	initBle(conf);
	
	// start sensor
	init_i2c();

	init_battery_level_adc(conf->battery_conf);

	uint8_t id=0;
	MMC56x3_get_product_ID(&id);
	uint8_t temp;
	MMC56x3_get_temperature(&temp);
	ESP_LOGI("MAIN", "MMC5603 product id %d", id);
	ESP_LOGI("MAIN", "MMC measured temp is %d", temp);
	update_bridge_offset(conf->power_conf->data);
	
	init_scd4x();
	scd4x_power_down();
	if(conf->sensor->mode & SCD4X_CAPTURE_ENABLED){
		TaskHandle_t sensor_fetch_handle;
		xTaskCreate(fetch_sensor_task, "FETCH_SENSOR", 4096, conf, tskIDLE_PRIORITY, &sensor_fetch_handle);
	}

	while(1){
		/*int32_t x,y,z;
		MMC56x3_get_mag_field(&x, &y, &z);
		float bx, by, bz;
		MMC56x3_to_mG(x, y, z, &bx, &by, &bz);
		ESP_LOGI("MAIN", "BField x %ld, y %ld, z %ld", x, y, z);
		ESP_LOGI("MAIN", "BField x %f mG, y %f mG, z %f mG", bx, by, bz);*/
		vTaskDelay(1000 / portTICK_PERIOD_MS);
	}
}

void fetch_sensor_task(void* pvParameters){
	configuration_data_t* mainConf = (configuration_data_t*) pvParameters;
	scd4x_config_t* conf = mainConf->sensor;
	scd4x_data_t* measures = conf->measure;
	int sensorStarted = false;
	while(1){
		ESP_LOGI("MAIN", "witing for %d sec", conf->delay);
		for(int i=0, oldEnable=conf->enabled; i<conf->delay || !conf->enabled; i++){
			vTaskDelay(1000 / portTICK_PERIOD_MS);
			if(conf->enabled != oldEnable) break;
			ESP_LOGI("MAIN", "waiting");
		}
		ESP_LOGI("MAIN", "sensor status changed");

		if(!conf->enabled){
			if(sensorStarted){
				scd4x_power_down();
				sensorStarted = false;
			}
			else continue;
		}
		else{
			if(!sensorStarted){
				scd4x_wait_wake_up();
				scd4x_measure_single_shot();
				update_scd4x_measures(measures);
				start_scd4x_measure(conf);
			}
		}

		if(conf->mode == SCD4X_SS_MODE) scd4x_measure_single_shot();
		ESP_LOGI("MAIN", "reading sensor");
		update_scd4x_measures(measures);
		update_led_status(mainConf->leds, mainConf->led_nb, conf->measure->co2);
		ble_sensor_notify();
		ESP_LOGI("MAIN", "co2 : %u ppm, temp : %ld m°C, hum : %ld mRH", conf->measure->co2, conf->measure->temperature, conf->measure->humidity);
	}
}

void init_nvs(void){
	esp_err_t ret = nvs_flash_init();
	if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
		ESP_ERROR_CHECK(nvs_flash_erase());
		ret = nvs_flash_init();
	}
	ESP_ERROR_CHECK(ret);
}

void init_i2c(){
	int i2c_master_port = I2C_NUM_0;
	i2c_config_t conf = {
		.mode = I2C_MODE_MASTER,
    .sda_io_num = CONFIG_SDA_PIN,
    .sda_pullup_en = GPIO_PULLUP_DISABLE,
    .scl_io_num = CONFIG_SCL_PIN,
    .scl_pullup_en = GPIO_PULLUP_DISABLE,
    .master.clk_speed = 10000,
    // .clk_flags = 0,          /*!< Optional, you can use I2C_SCLK_SRC_FLAG_* flags to choose i2c source clock here. */
  };
  i2c_param_config(i2c_master_port, &conf);
  i2c_driver_install(i2c_master_port, I2C_MODE_MASTER, 0, 0, 0);
}

void init_scd4x(){
  scd4x_wake_up();
  scd4x_stop_periodic_measurement();
  scd4x_reinit();
}