chris
/
Weather_ESP
1
0
Bifurcation 0
Code Versions 0 Activité
Repo for ESP32 Weather Station Development
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
9 Révisions
2 Branches
4.3MB
Aborescence: 1cb397c98a
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '1cb397c98a'
${ noResults }
Weather_ESP/main/main.c

506 lignes
18KB
Brut Annotations Historique 

  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. 

  499. 

  500. 	while (1) {

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

  502. 		vTaskDelay(1000 / portTICK_PERIOD_MS);

  503. 	}

  504. }