chris
/
Weather_ESP
1
0
Fork 0
Code Releases 0 Activity
Repo for ESP32 Weather Station Development
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13 Commits
2 Branches
4.3MB
Tree: 1e0c5837d6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1e0c5837d6'
${ noResults }
Weather_ESP/main/main.c

509 lines
18KB
Raw Blame History 

  1. #include "bme280.h"

  2. #include "bme280_defs.h"

  3. #include "driver/i2c.h"

  4. #include "display.h"

  5. #include <esp_log.h>

  6. #include <freertos/FreeRTOS.h>

  7. #include <freertos/task.h>

  8. //#include <esp_wifi.h>

  9. //#include "freertos/event_groups.h"

  10. //#include "nvs_flash.h"

  11. //#include <esp_http_server.h>

  12. //#include <sys/param.h>

  13. 

  14. //#define WIFI_SSID     "Netzknecht"

  15. //#define WIFI_PASS     "***REMOVED***"

  16. //#define WIFI_RETRIES  10

  17. //

  18. //static EventGroupHandle_t s_wifi_event_group;

  19. //#define WIFI_CONNECTED_BIT BIT0

  20. //#define WIFI_FAIL_BIT      BIT1

  21. //

  22. //static const char *TAG = "wifi station";

  23. //static int s_retry_num = 0;

  24. //

  25. //char cur_value_str[255];

  26. //

  27. ///* An HTTP GET handler */

  28. //static esp_err_t hello_get_handler(httpd_req_t *req)

  29. //{

  30. //    char*  buf;

  31. //    size_t buf_len;

  32. //

  33. //    /* Get header value string length and allocate memory for length + 1,

  34. //     * extra byte for null termination */

  35. //    buf_len = httpd_req_get_hdr_value_len(req, "Host") + 1;

  36. //    if (buf_len > 1) {

  37. //        buf = malloc(buf_len);

  38. //        /* Copy null terminated value string into buffer */

  39. //        if (httpd_req_get_hdr_value_str(req, "Host", buf, buf_len) == ESP_OK) {

  40. //            ESP_LOGI(TAG, "Found header => Host: %s", buf);

  41. //        }

  42. //        free(buf);

  43. //    }

  44. //

  45. //    buf_len = httpd_req_get_hdr_value_len(req, "Test-Header-2") + 1;

  46. //    if (buf_len > 1) {

  47. //        buf = malloc(buf_len);

  48. //        if (httpd_req_get_hdr_value_str(req, "Test-Header-2", buf, buf_len) == ESP_OK) {

  49. //            ESP_LOGI(TAG, "Found header => Test-Header-2: %s", buf);

  50. //        }

  51. //        free(buf);

  52. //    }

  53. //

  54. //    buf_len = httpd_req_get_hdr_value_len(req, "Test-Header-1") + 1;

  55. //    if (buf_len > 1) {

  56. //        buf = malloc(buf_len);

  57. //        if (httpd_req_get_hdr_value_str(req, "Test-Header-1", buf, buf_len) == ESP_OK) {

  58. //            ESP_LOGI(TAG, "Found header => Test-Header-1: %s", buf);

  59. //        }

  60. //        free(buf);

  61. //    }

  62. //

  63. //    /* Read URL query string length and allocate memory for length + 1,

  64. //     * extra byte for null termination */

  65. //    buf_len = httpd_req_get_url_query_len(req) + 1;

  66. //    if (buf_len > 1) {

  67. //        buf = malloc(buf_len);

  68. //        if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {

  69. //            ESP_LOGI(TAG, "Found URL query => %s", buf);

  70. //            char param[32];

  71. //            /* Get value of expected key from query string */

  72. //            if (httpd_query_key_value(buf, "query1", param, sizeof(param)) == ESP_OK) {

  73. //                ESP_LOGI(TAG, "Found URL query parameter => query1=%s", param);

  74. //            }

  75. //            if (httpd_query_key_value(buf, "query3", param, sizeof(param)) == ESP_OK) {

  76. //                ESP_LOGI(TAG, "Found URL query parameter => query3=%s", param);

  77. //            }

  78. //            if (httpd_query_key_value(buf, "query2", param, sizeof(param)) == ESP_OK) {

  79. //                ESP_LOGI(TAG, "Found URL query parameter => query2=%s", param);

  80. //            }

  81. //        }

  82. //        free(buf);

  83. //    }

  84. //

  85. //    /* Set some custom headers */

  86. //    httpd_resp_set_hdr(req, "Custom-Header-1", "Custom-Value-1");

  87. //    httpd_resp_set_hdr(req, "Custom-Header-2", "Custom-Value-2");

  88. //

  89. //    /* Send response with custom headers and body set as the

  90. //     * string passed in user context*/

  91. //    const char* resp_str = cur_value_str;

  92. //    httpd_resp_send(req, resp_str, strlen(resp_str));

  93. //

  94. //    /* After sending the HTTP response the old HTTP request

  95. //     * headers are lost. Check if HTTP request headers can be read now. */

  96. //    if (httpd_req_get_hdr_value_len(req, "Host") == 0) {

  97. //        ESP_LOGI(TAG, "Request headers lost");

  98. //    }

  99. //    return ESP_OK;

  100. //}

  101. //

  102. //static httpd_uri_t hello = {

  103. //    .uri       = "/hello",

  104. //    .method    = HTTP_GET,

  105. //    .handler   = hello_get_handler,

  106. //    /* Let's pass response string in user

  107. //     * context to demonstrate it's usage */

  108. //    .user_ctx  = "Hello World!"

  109. //};

  110. //

  111. //static httpd_handle_t start_webserver(void)

  112. //{

  113. //    httpd_handle_t server = NULL;

  114. //    httpd_config_t config = HTTPD_DEFAULT_CONFIG();

  115. //

  116. //    // Start the httpd server

  117. //    ESP_LOGI(TAG, "Starting server on port: '%d'", config.server_port);

  118. //    if (httpd_start(&server, &config) == ESP_OK) {

  119. //        // Set URI handlers

  120. //        ESP_LOGI(TAG, "Registering URI handlers");

  121. //        httpd_register_uri_handler(server, &hello);

  122. //        return server;

  123. //    }

  124. //

  125. //    ESP_LOGI(TAG, "Error starting server!");

  126. //    return NULL;

  127. //}

  128. //

  129. //static void stop_webserver(httpd_handle_t server)

  130. //{

  131. //    // Stop the httpd server

  132. //    httpd_stop(server);

  133. //}

  134. //

  135. //static void disconnect_handler(void* arg, esp_event_base_t event_base,

  136. //                               int32_t event_id, void* event_data)

  137. //{

  138. //    httpd_handle_t* server = (httpd_handle_t*) arg;

  139. //    if (*server) {

  140. //        ESP_LOGI(TAG, "Stopping webserver");

  141. //        stop_webserver(*server);

  142. //        *server = NULL;

  143. //    }

  144. //}

  145. //

  146. //static void connect_handler(void* arg, esp_event_base_t event_base,

  147. //                            int32_t event_id, void* event_data)

  148. //{

  149. //    httpd_handle_t* server = (httpd_handle_t*) arg;

  150. //    if (*server == NULL) {

  151. //        ESP_LOGI(TAG, "Starting webserver");

  152. //        *server = start_webserver();

  153. //    }

  154. //}

  155. //

  156. //static void event_handler(void* arg, esp_event_base_t event_base,

  157. //                                int32_t event_id, void* event_data)

  158. //{

  159. //    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {

  160. //        esp_wifi_connect();

  161. //    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {

  162. //        if (s_retry_num < WIFI_RETRIES) {

  163. //            esp_wifi_connect();

  164. //            s_retry_num++;

  165. //            ESP_LOGI(TAG, "retry to connect to the AP");

  166. //        } else {

  167. //            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);

  168. //        }

  169. //        ESP_LOGI(TAG,"connect to the AP fail");

  170. //    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {

  171. //        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;

  172. //        ESP_LOGI(TAG, "got ip:%s",

  173. //                 ip4addr_ntoa(&event->ip_info.ip));

  174. //        s_retry_num = 0;

  175. //        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);

  176. //    }

  177. //}

  178. 

  179. //void wifi_init_sta()

  180. //{

  181. //    s_wifi_event_group = xEventGroupCreate();

  182. //

  183. //    tcpip_adapter_init();

  184. //

  185. //    ESP_ERROR_CHECK(esp_event_loop_create_default());

  186. //

  187. //    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

  188. //    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

  189. //

  190. //    //tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);

  191. //    //tcpip_adapter_ip_info_t info;

  192. //    //ip4_addr_t gw;

  193. //    //gw.addr = ipaddr_addr("192.168.0.1");

  194. //    //info.gw = gw;

  195. //    //ip4_addr_t ip;

  196. //    //ip.addr = ipaddr_addr("192.168.0.110");

  197. //    //info.ip = ip;

  198. //    //ip4_addr_t netmask;

  199. //    //netmask.addr = ipaddr_addr("255.255.255.0");

  200. //    //info.netmask = netmask;

  201. //    //tcpip_adapter_sta_start(0, &info);

  202. //

  203. //    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL));

  204. //    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL));

  205. //

  206. //    wifi_config_t wifi_config = {

  207. //        .sta = {

  208. //            .ssid = WIFI_SSID,

  209. //            .password = WIFI_PASS

  210. //        },

  211. //    };

  212. //    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );

  213. //    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );

  214. //    ESP_ERROR_CHECK(esp_wifi_start() );

  215. //

  216. //    ESP_LOGI(TAG, "wifi_init_sta finished.");

  217. //

  218. //    /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum

  219. //     * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */

  220. //    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,

  221. //            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,

  222. //            pdFALSE,

  223. //            pdFALSE,

  224. //            portMAX_DELAY);

  225. //

  226. //    //tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &info);

  227. //    /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually

  228. //     * happened. */

  229. //    if (bits & WIFI_CONNECTED_BIT) {

  230. //        ESP_LOGI(TAG, "connected to ap SSID:%s password:%s",

  231. //        		WIFI_SSID, WIFI_PASS);

  232. //    } else if (bits & WIFI_FAIL_BIT) {

  233. //        ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s",

  234. //        		WIFI_SSID, WIFI_PASS);

  235. //    } else {

  236. //        ESP_LOGE(TAG, "UNEXPECTED EVENT");

  237. //    }

  238. //

  239. //    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler));

  240. //    ESP_ERROR_CHECK(esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler));

  241. //    vEventGroupDelete(s_wifi_event_group);

  242. //}

  243. 

  244. void i2c_setup()

  245. {

  246. 	printf("Setting up I�C driver on port 1... ");

  247. 	i2c_config_t config;

  248. 	config.mode = I2C_MODE_MASTER;

  249. 	config.sda_io_num = 33;

  250. 	config.sda_pullup_en = GPIO_PULLUP_ENABLE;

  251. 	config.scl_io_num = 32;

  252. 	config.scl_pullup_en = GPIO_PULLUP_ENABLE;

  253. 	config.master.clk_speed = 100000;

  254. 	i2c_param_config(I2C_NUM_0, &config);

  255. 	printf("Set driver parameters... ");

  256. 	esp_err_t err = i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0);

  257. 	if (err == ESP_OK)

  258. 		printf("Driver installed!\n");

  259. 	else if (err == ESP_ERR_INVALID_ARG)

  260. 		printf("Driver install failed, invalid arguments!\n");

  261. 	else

  262. 		printf("Driver install failed!\n");

  263. }

  264. 

  265. int8_t i2c_read(uint8_t dev_id, uint8_t reg_addr, uint8_t *data, uint16_t len) {

  266. 	i2c_cmd_handle_t cmd = i2c_cmd_link_create();

  267. 	i2c_master_start(cmd);

  268. 	i2c_master_write_byte(cmd, dev_id << 1 | I2C_MASTER_WRITE, 1);

  269. 	i2c_master_write_byte(cmd, reg_addr, 1);

  270. 	i2c_master_start(cmd);

  271. 	i2c_master_write_byte(cmd, dev_id << 1 | I2C_MASTER_READ, 1);

  272. 	if (len > 1) {

  273. 		i2c_master_read(cmd, data, len - 1, I2C_MASTER_ACK);

  274. 	}

  275. 	i2c_master_read_byte(cmd, data + len - 1, I2C_MASTER_NACK);

  276. 	i2c_master_stop(cmd);

  277. 	i2c_master_cmd_begin(I2C_NUM_0, cmd, 500 / portTICK_RATE_MS);

  278. 	i2c_cmd_link_delete(cmd);

  279. 	return 0;

  280. }

  281. 

  282. int8_t i2c_write(uint8_t dev_id, uint8_t reg_addr, uint8_t *data, uint16_t len) {

  283. 	//printf("Writing to bus: dev_id=%x, reg_addr=%x, data=%p, length=%u\n", dev_id, reg_addr, data, len);

  284. 	i2c_cmd_handle_t cmd = i2c_cmd_link_create();

  285. 	i2c_master_start(cmd);

  286. 	i2c_master_write_byte(cmd, (dev_id << 1) | I2C_MASTER_WRITE, 1);

  287. 	i2c_master_write_byte(cmd, reg_addr, 1);

  288. 	i2c_master_write(cmd, data, len, 1);

  289. 	i2c_master_stop(cmd);

  290. 	i2c_master_cmd_begin(I2C_NUM_0, cmd, 500 / portTICK_RATE_MS);

  291. 	i2c_cmd_link_delete(cmd);

  292. 	return 0;

  293. }

  294. 

  295. void i2c_delay(uint32_t period) {

  296. 	vTaskDelay(period / portTICK_PERIOD_MS);

  297. }

  298. 

  299. void i2c_shutdown()

  300. {

  301. 	printf("Shutting down I�C bus... ");

  302. 	esp_err_t err = i2c_driver_delete(I2C_NUM_0);

  303. 	if (err == ESP_ERR_INVALID_ARG)

  304. 		printf("Failed, invalid arguments!\n");

  305. 	else

  306. 		printf("Success!\n");

  307. }

  308. 

  309. void read_sensor(struct bme280_dev* dev, int32_t* temp, uint32_t* pressure, uint32_t* humidity) {

  310. 

  311. 	uint8_t settings_sel;

  312. 	uint32_t req_delay;

  313. 	struct bme280_data comp_data;

  314. 

  315. 	dev->settings.osr_h = BME280_OVERSAMPLING_16X;

  316. 	dev->settings.osr_p = BME280_OVERSAMPLING_16X;

  317. 	dev->settings.osr_t = BME280_OVERSAMPLING_16X;

  318. 	dev->settings.filter = BME280_FILTER_COEFF_16;

  319. 

  320. 	settings_sel = BME280_OSR_PRESS_SEL | BME280_OSR_TEMP_SEL | BME280_OSR_HUM_SEL | BME280_FILTER_SEL;

  321. 	bme280_set_sensor_settings(settings_sel, dev);

  322. 

  323. 	req_delay = 12*bme280_cal_meas_delay(&(dev->settings));

  324. 

  325. 	/* Continuously stream sensor data */

  326. 	bme280_set_sensor_mode(BME280_FORCED_MODE, dev);

  327. 	/* Wait for the measurement to complete and print data @25Hz */

  328. 	dev->delay_ms(req_delay / portTICK_PERIOD_MS);

  329. 	bme280_get_sensor_data(BME280_ALL, &comp_data, dev);

  330. 	*temp = comp_data.temperature;

  331. 	*pressure = comp_data.pressure;

  332. 	*humidity = comp_data.humidity;

  333. }

  334. 

  335. void read_sensor2(struct bme280_dev* dev, int32_t* temp, uint32_t* pressure, uint32_t* humidity) {

  336. 

  337. 	uint8_t settings_sel;

  338. 	uint32_t req_delay;

  339. 	struct bme280_data comp_data;

  340. 

  341. 	dev->settings.osr_h = BME280_OVERSAMPLING_16X;

  342. 	dev->settings.osr_p = BME280_OVERSAMPLING_16X;

  343. 	dev->settings.osr_t = BME280_OVERSAMPLING_16X;

  344. 	dev->settings.filter = BME280_FILTER_COEFF_16;

  345. 

  346. 	settings_sel = BME280_OSR_PRESS_SEL | BME280_OSR_TEMP_SEL | BME280_OSR_HUM_SEL | BME280_FILTER_SEL;

  347. 	bme280_set_sensor_settings(settings_sel, dev);

  348. 	/*Calculate the minimum delay required between consecutive measurement based upon the sensor enabled

  349. 		 *  and the oversampling configuration. */

  350. 	req_delay = 12*bme280_cal_meas_delay(&(dev->settings));

  351. 

  352. 	bme280_set_sensor_mode(BME280_FORCED_MODE, dev);

  353. 	/* Wait for the measurement to complete and print data @25Hz */

  354. 	dev->delay_ms(req_delay / portTICK_PERIOD_MS);

  355. 	bme280_get_sensor_data(BME280_ALL, &comp_data, dev);

  356. 	*temp = comp_data.temperature;

  357. 	*pressure = comp_data.pressure;

  358. 	*humidity = comp_data.humidity;

  359. }

  360. 

  361. //void print_data(u8g2_t* u8g2, int32_t temp_raw, uint32_t pressure_raw, uint32_t humidity_raw,

  362. //		int32_t temp2_raw, uint32_t pressure2_raw, uint32_t humidity2_raw) {

  363. //	// Calc temperature pre and post comma values

  364. //	int32_t temp_pre = temp_raw / 100;

  365. //	int32_t temp_post = (abs(temp_raw) % 100) / 10;

  366. //	int32_t temp2_pre = temp2_raw / 100;

  367. //	int32_t temp2_post = (abs(temp2_raw) % 100) / 10;

  368. //

  369. //	// Calc pressure values

  370. //	uint32_t press = pressure_raw / 100;

  371. //	uint32_t press2 = pressure2_raw / 100;

  372. //

  373. //	// Calc humidity pre and post comma values

  374. //	uint32_t humid_pre = humidity_raw / 1024;

  375. //	uint32_t humid_post = (humidity_raw - humid_pre*1024) * 10 / 1024;

  376. //	uint32_t humid2_pre = humidity2_raw / 1024;

  377. //	uint32_t humid2_post = (humidity2_raw - humid2_pre*1024) * 10 / 1024;

  378. //

  379. //	// Format temperatures

  380. //	char temp_str[2*(sizeof(int)*8+1)+5] = ""; // ""

  381. //	char temp_pre_str[sizeof(int)*8+1];

  382. //	itoa(temp_pre, temp_pre_str, 10);

  383. //	char temp_post_str[sizeof(int)*8+1];

  384. //	itoa(temp_post, temp_post_str, 10);

  385. //	char temp2_pre_str[sizeof(int)*8+1];

  386. //	itoa(temp2_pre, temp2_pre_str, 10);

  387. //	char temp2_post_str[sizeof(int)*8+1];

  388. //	itoa(temp2_post, temp2_post_str, 10);

  389. //	if (temp_pre < 10)

  390. //		strcat(temp_str, " "); // Add space if first temperatur is just one digit long " "

  391. //	strcat(temp_str, temp_pre_str); // " 1"

  392. //	strcat(temp_str, ","); // " 1,"

  393. //	strcat(temp_str, temp_post_str); // " 1,3"

  394. //	strcat(temp_str, " "); // " 1,3 "

  395. //	if (temp2_pre >= 0)

  396. //		strcat(temp_str, " "); // Add space if there is no minus sign " 1,3  "

  397. //	if (temp2_pre < 10)

  398. //		strcat(temp_str, " "); // Add space if second temperatur is just one digit long " 1,3   "

  399. //	strcat(temp_str, temp2_pre_str); // " 1,3   7"

  400. //	strcat(temp_str, ","); // " 1,3   7,"

  401. //	strcat(temp_str, temp2_post_str); // " 1,3   7,2"

  402. //	strcat(temp_str, "  �C"); // " 1,3   7,2  �C"

  403. //

  404. //	// Format temperatures

  405. //	char humid_str[2*(sizeof(int)*8+1)+5] = ""; // ""

  406. //	char humid_pre_str[sizeof(int)*8+1];

  407. //	itoa(humid_pre, humid_pre_str, 10);

  408. //	char humid_post_str[sizeof(int)*8+1];

  409. //	itoa(humid_post, humid_post_str, 10);

  410. //	char humid2_pre_str[sizeof(int)*8+1];

  411. //	itoa(humid2_pre, humid2_pre_str, 10);

  412. //	char humid2_post_str[sizeof(int)*8+1];

  413. //	itoa(humid2_post, humid2_post_str, 10);

  414. //	strcat(humid_str, humid_pre_str); // "12"

  415. //	strcat(humid_str, ","); // "12,"

  416. //	strcat(humid_str, humid_post_str); // "12,5"

  417. //	strcat(humid_str, "  "); // "12,5  "

  418. //	strcat(humid_str, humid2_pre_str); // "12,5  45"

  419. //	strcat(humid_str, ","); // "12,5  45,"

  420. //	strcat(humid_str, humid2_post_str); // "12,5  45,23"

  421. //	strcat(humid_str, "   %"); // "12,5  45,23   %"

  422. //

  423. //	// Format pressure

  424. //	char pressure_str[2*(sizeof(int)*8+1)+5] = ""; // ""

  425. //	char press1_str[sizeof(int)*8+1];

  426. //	itoa(press, press1_str, 10);

  427. //	char press2_str[sizeof(int)*8+1];

  428. //	itoa(press2, press2_str, 10);

  429. //	if (press < 1000)

  430. //		strcat(pressure_str, " ");

  431. //	strcat(pressure_str, press1_str);

  432. //	strcat(pressure_str, "  ");

  433. //	if (press2 < 1000)

  434. //		strcat(pressure_str, " ");

  435. //	strcat(pressure_str, press2_str);

  436. //	strcat(pressure_str, " hPa");

  437. //

  438. //	u8g2_ClearBuffer(u8g2);

  439. //	u8g2_SetFont(u8g2, u8g2_font_profont17_mf);

  440. //	int8_t fontheight = u8g2_GetAscent(u8g2);

  441. //	int8_t fontmargin = abs(u8g2_GetDescent(u8g2))+2;

  442. //	u8g2_DrawStr(u8g2, 0, fontheight, " IN    OUT   ");

  443. //	u8g2_DrawStr(u8g2, 0, 2*fontheight + fontmargin, temp_str);

  444. //	u8g2_DrawStr(u8g2, 0, 3*fontheight + 2*fontmargin, humid_str);

  445. //	u8g2_DrawStr(u8g2, 0, 4*fontheight + 3*fontmargin, pressure_str);

  446. //	u8g2_SendBuffer(u8g2);

  447. //}

  448. 

  449. 

  450. 

  451. void app_main(void)

  452. {

  453. 	int32_t temp = -12;

  454. 	uint32_t pressure = 0;

  455. 	uint32_t humidity = 0;

  456. 	int32_t temp2 = 0;

  457. 	uint32_t pressure2 = 0;

  458. 	uint32_t humidity2 = 0;

  459. 

  460. 	// INIT SENSOR

  461. 	i2c_setup();

  462. 	struct bme280_dev dev;

  463. 	dev.dev_id = 0x76;

  464. 	dev.intf = BME280_I2C_INTF;

  465. 	dev.read = i2c_read;

  466. 	dev.write = i2c_write;

  467. 	dev.delay_ms = i2c_delay;

  468. 	bme280_init(&dev);

  469. 

  470. 	// INIT SENSOR2

  471. 	struct bme280_dev dev2;

  472. 	dev2.dev_id = 0x77;

  473. 	dev2.intf = BME280_I2C_INTF;

  474. 	dev2.read = i2c_read;

  475. 	dev2.write = i2c_write;

  476. 	dev2.delay_ms = i2c_delay;

  477. 	bme280_init(&dev2);

  478. 

  479. 	// INIT WIFI

  480. 	//Initialize NVS

  481. //	esp_err_t ret = nvs_flash_init();

  482. //	if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {

  483. //	  ESP_ERROR_CHECK(nvs_flash_erase());

  484. //	  ret = nvs_flash_init();

  485. //	}

  486. //	ESP_ERROR_CHECK(ret);

  487. //

  488. //	ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");

  489. //	wifi_init_sta();

  490. 

  491. 	// INIT WEBSERVER

  492. //	static httpd_handle_t server = NULL;

  493. //	ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &connect_handler, &server));

  494. //	ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &disconnect_handler, &server));

  495. //	server = start_webserver();

  496. 

  497. 	init_display();

  498. 	read_sensor(&dev, &temp, &pressure, &humidity);

  499. 	read_sensor(&dev2, &temp2, &pressure2, &humidity2);

  500. 	display_data(temp, pressure, humidity, temp2, pressure2, humidity2);

  501. 	while (1) {

  502. 		read_sensor(&dev, &temp, &pressure, &humidity);

  503. 		read_sensor(&dev2, &temp2, &pressure2, &humidity2);

  504. 		display_data(temp, pressure, humidity, temp2, pressure2, humidity2);

  505. 		vTaskDelay(1000 / portTICK_PERIOD_MS);

  506. 	}

  507. }