/* weather.c - Weather data retrieval from api.openweathermap.org This file is part of the ESP32 Everest Run project https://github.com/krzychb/esp32-everest-run Copyright (c) 2016 Krzysztof Budzynski This work is licensed under the Apache License, Version 2.0, January 2004 See the file LICENSE for details. */ #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_system.h" #include "esp_log.h" #include #include #include "meteofrance.h" #include "cJSON.h" #include "esp_http_client.h" #include "esp_tls.h" static const char* TAG = "MeteoFrance"; /* Constants that aren't configurable in menuconfig Typically only LOCATION_ID may need to be changed */ #define WEB_SERVER "webservice.meteofrance.com" //"192.168.0.10" //"www.example.com"// //"webservice.meteofrance.com" #define WEB_PORT 80//5403 //80 #define WEB_URL "/forecast" #define TOKEN "__Wj7dVSTjV9YGu1guveLyDq0g7S7TfTjaHBTPTpO0kj8__" // Location ID to get the weather data for //#define LOCATION_ID "756135" #define LATITUDE "49.22017054145735" #define LONGITUDE "3.92188756221628" #define WEB_QUERY "token="TOKEN"&lat="LATITUDE"&lon="LONGITUDE #define MAX_HTTP_OUTPUT_BUFFER 32000 static weather_data weather; static struct meteoforecast_data datas[5]; inline int MIN(int a, int b) { return a > b ? b : a; } void printftemp(struct forecast_temp *tmp){ printf(" Temps Min:%f, Max:%f", tmp->min, tmp->max); } #define MAX_SIZE 80 void printffd(struct meteoforecast_data *tmp){ struct tm timeinfo = { 0 }; localtime_r(&tmp->datetime, &timeinfo); char buffer[ MAX_SIZE ]; strftime(buffer, MAX_SIZE, "%c", &timeinfo); char strftime_buf[64]; sprintf(strftime_buf,"%d %d %d", timeinfo.tm_wday, timeinfo.tm_mday, timeinfo.tm_mon+1); ESP_LOGE(TAG,"%s",strftime_buf); printf("IsValid:%s date:%s, Min:%.1f Max:%.1f Desc:%s\n", tmp->isValid ?"true":"false", buffer, tmp->previsions.min, tmp->previsions.max, tmp->previsions.desc); } esp_err_t _http_event_handler(esp_http_client_event_t *evt) { static char *output_buffer; // Buffer to store response of http request from event handler static int output_len; // Stores number of bytes read switch(evt->event_id) { case HTTP_EVENT_ERROR: ESP_LOGD(TAG, "HTTP_EVENT_ERROR"); break; case HTTP_EVENT_ON_CONNECTED: ESP_LOGD(TAG, "HTTP_EVENT_ON_CONNECTED"); break; case HTTP_EVENT_HEADER_SENT: ESP_LOGD(TAG, "HTTP_EVENT_HEADER_SENT"); break; case HTTP_EVENT_ON_HEADER: ESP_LOGD(TAG, "HTTP_EVENT_ON_HEADER, key=%s, value=%s", evt->header_key, evt->header_value); break; case HTTP_EVENT_ON_DATA: ESP_LOGD(TAG, "HTTP_EVENT_ON_DATA, len=%d", evt->data_len); // Clean the buffer in case of a new request if (output_len == 0 && evt->user_data) { // we are just starting to copy the output data into the use memset(evt->user_data, 0, MAX_HTTP_OUTPUT_BUFFER); } /* * Check for chunked encoding is added as the URL for chunked encoding used in this example returns binary data. * However, event handler can also be used in case chunked encoding is used. */ if (!esp_http_client_is_chunked_response(evt->client)) { // If user_data buffer is configured, copy the response into the buffer int copy_len = 0; if (evt->user_data) { // The last byte in evt->user_data is kept for the NULL character in case of out-of-bound access. copy_len = MIN(evt->data_len, (MAX_HTTP_OUTPUT_BUFFER - output_len)); if (copy_len) { memcpy(evt->user_data + output_len, evt->data, copy_len); } } else { int content_len = esp_http_client_get_content_length(evt->client); if (output_buffer == NULL) { // We initialize output_buffer with 0 because it is used by strlen() and similar functions therefore should be null terminated. output_buffer = (char *) calloc(content_len + 1, sizeof(char)); output_len = 0; if (output_buffer == NULL) { ESP_LOGE(TAG, "Failed to allocate memory for output buffer"); return ESP_FAIL; } } copy_len = MIN(evt->data_len, (content_len - output_len)); if (copy_len) { memcpy(output_buffer + output_len, evt->data, copy_len); } } output_len += copy_len; } break; case HTTP_EVENT_ON_FINISH: ESP_LOGD(TAG, "HTTP_EVENT_ON_FINISH"); if (output_buffer != NULL) { // Response is accumulated in output_buffer. Uncomment the below line to print the accumulated response // ESP_LOG_BUFFER_HEX(TAG, output_buffer, output_len); free(output_buffer); output_buffer = NULL; } output_len = 0; break; case HTTP_EVENT_DISCONNECTED: ESP_LOGI(TAG, "HTTP_EVENT_DISCONNECTED"); int mbedtls_err = 0; esp_err_t err = esp_tls_get_and_clear_last_error((esp_tls_error_handle_t)evt->data, &mbedtls_err, NULL); if (err != 0) { ESP_LOGI(TAG, "Last esp error code: 0x%x", err); ESP_LOGI(TAG, "Last mbedtls failure: 0x%x", mbedtls_err); } if (output_buffer != NULL) { free(output_buffer); output_buffer = NULL; } output_len = 0; break; case HTTP_EVENT_REDIRECT: ESP_LOGD(TAG, "HTTP_EVENT_REDIRECT"); esp_http_client_set_header(evt->client, "From", "user@example.com"); esp_http_client_set_header(evt->client, "Accept", "text/html"); esp_http_client_set_redirection(evt->client); break; } return ESP_OK; } char *JSON_Types(int type) { if (type == cJSON_Invalid) return ("cJSON_Invalid"); if (type == cJSON_False) return ("cJSON_False"); if (type == cJSON_True) return ("cJSON_True"); if (type == cJSON_NULL) return ("cJSON_NULL"); if (type == cJSON_Number) return ("cJSON_Number"); if (type == cJSON_String) return ("cJSON_String"); if (type == cJSON_Array) return ("cJSON_Array"); if (type == cJSON_Object) return ("cJSON_Object"); if (type == cJSON_Raw) return ("cJSON_Raw"); return NULL; } void JSON_Parse(const cJSON * const root) { //ESP_LOGI(TAG, "root->type=%s", JSON_Types(root->type)); cJSON *current_element = NULL; //ESP_LOGI(TAG, "roo->child=%p", root->child); //ESP_LOGI(TAG, "roo->next =%p", root->next); int i=0; cJSON *df = cJSON_GetObjectItem(root,"daily_forecast"); if(!cJSON_IsArray(df)){ ESP_LOGE(TAG,"Pas de tableau ^^"); }else{ cJSON_ArrayForEach(current_element, df) { struct meteoforecast_data datasT; //ESP_LOGI(TAG, "type=%s", JSON_Types(current_element->type)); cJSON *dt = cJSON_GetObjectItem(current_element,"dt"); if(cJSON_IsNumber(dt)){ datasT.datetime=dt->valueint; cJSON *temps = cJSON_GetObjectItem(current_element,"T"); datasT.previsions.min=cJSON_GetObjectItem(temps,"min")->valuedouble; datasT.previsions.max=cJSON_GetObjectItem(temps,"max")->valuedouble; cJSON *weather12=cJSON_GetObjectItem(current_element,"weather12H"); strncpy(datasT.previsions.desc,cJSON_GetObjectItem(weather12,"desc")->valuestring,24); strncpy(datasT.previsions.icon,cJSON_GetObjectItem(weather12,"icon")->valuestring,7); datasT.isValid=true; //ESP_LOGE(TAG,"Donnees lues"); //printffd(&datasT); datas[i++]=datasT; if(i==3){break;} } } } } static bool process_response_body(const char * body) { cJSON *root = cJSON_Parse(body); JSON_Parse(root); cJSON_Delete(root); return true; } static void http_request_task(void *pvParameter) { while(1) { ESP_LOGE(TAG,"Début recup méteo --------------------------"); weather.data_retreived_cb_start(NULL); char *local_response_buffer = heap_caps_malloc((MAX_HTTP_OUTPUT_BUFFER + 1)*(sizeof(char)),MALLOC_CAP_SPIRAM); //char local_response_buffer[MAX_HTTP_OUTPUT_BUFFER + 1] = {0}; /** * NOTE: All the configuration parameters for http_client must be spefied either in URL or as host and path parameters. * If host and path parameters are not set, query parameter will be ignored. In such cases, * query parameter should be specified in URL. * * If URL as well as host and path parameters are specified, values of host and path will be considered. */ esp_http_client_config_t config = { .host = WEB_SERVER, .port = WEB_PORT, .path = WEB_URL, .query = WEB_QUERY, .event_handler = _http_event_handler, .user_data = local_response_buffer, // Pass address of local buffer to get response .disable_auto_redirect = true, }; esp_http_client_handle_t client = esp_http_client_init(&config); char url[50]; esp_http_client_get_url(client,url,50); ESP_LOGE(TAG,"%s",url); // GET esp_err_t err = esp_http_client_perform(client); if (err == ESP_OK) { ESP_LOGI(TAG, "HTTP GET Status = %d, content_length = %"PRId64, esp_http_client_get_status_code(client), esp_http_client_get_content_length(client)); } else { ESP_LOGE(TAG, "HTTP GET request failed: %s", esp_err_to_name(err)); } //ESP_LOGE(TAG, "%s",local_response_buffer); bool weather_data_phrased = false; weather_data_phrased = process_response_body(local_response_buffer); weather.data_retreived_cb(datas); esp_http_client_cleanup(client); //http_client_request(&http_client, WEB_SERVER, get_request); vTaskDelay(weather.retreival_period / portTICK_PERIOD_MS); } } void on_weather_data_retrieval(weather_data_callback data_retreived_cb) { weather.data_retreived_cb = data_retreived_cb; } void on_weather_data_retrieval_start(weather_data_callback data_retreived_cb_start) { weather.data_retreived_cb_start = data_retreived_cb_start; } void initialise_weather_data_retrieval(unsigned long retreival_period) { weather.retreival_period = retreival_period; //http_client_on_process_chunk(&http_client, process_chunk); //http_client_on_disconnected(&http_client, disconnected); xTaskCreate(&http_request_task, "http_request_task", 10 * 2048, NULL, 5, NULL); ESP_LOGI(TAG, "HTTP request task started"); }