From 21b326092e21b529e9dc83e35470bb94ff335452 Mon Sep 17 00:00:00 2001 From: vinc Date: Sat, 18 May 2024 15:17:13 +0200 Subject: [PATCH] =?UTF-8?q?Version=20AP=20avec=20mdp,=20bateaux=20en=20r?= =?UTF-8?q?=C3=A9gime=20TOR?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- main/CMakeLists.txt | 2 + main/Kconfig.projbuild | 13 ++ main/app_main.c | 155 +++++++++++++ main/bsp.c | 399 ++++++++++++++++++++++++++++++++++ main/bsp.h | 180 ++++++++++++++++ main/loop.c | 480 +++++++++++++++++++++++++++++++++++++++++ main/loop.h | 19 ++ main/mqttHandler.c | 425 ++++++++++++++++++++++++++++++++++++ main/mqttHandler.h | 13 ++ main/wifi.c | 174 +++++++++++++++ main/wifi.h | 26 +++ 11 files changed, 1886 insertions(+) create mode 100644 main/CMakeLists.txt create mode 100644 main/Kconfig.projbuild create mode 100644 main/app_main.c create mode 100644 main/bsp.c create mode 100644 main/bsp.h create mode 100644 main/loop.c create mode 100644 main/loop.h create mode 100644 main/mqttHandler.c create mode 100644 main/mqttHandler.h create mode 100644 main/wifi.c create mode 100644 main/wifi.h diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt new file mode 100644 index 0000000..a255ee9 --- /dev/null +++ b/main/CMakeLists.txt @@ -0,0 +1,2 @@ +idf_component_register(SRCS "loop.c" "mqttHandler.c" "wifi.c" "bsp.c" "app_main.c" + INCLUDE_DIRS ".") diff --git a/main/Kconfig.projbuild b/main/Kconfig.projbuild new file mode 100644 index 0000000..c11539f --- /dev/null +++ b/main/Kconfig.projbuild @@ -0,0 +1,13 @@ +menu "Example Configuration" + + config BROKER_URL + string "Broker URL" + default "mqtt://mqtt.eclipseprojects.io" + help + URL of the broker to connect to + + config BROKER_URL_FROM_STDIN + bool + default y if BROKER_URL = "FROM_STDIN" + +endmenu diff --git a/main/app_main.c b/main/app_main.c new file mode 100644 index 0000000..ca508eb --- /dev/null +++ b/main/app_main.c @@ -0,0 +1,155 @@ +/* MQTT (over TCP) Example + + This example code is in the Public Domain (or CC0 licensed, at your option.) + + Unless required by applicable law or agreed to in writing, this + software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + CONDITIONS OF ANY KIND, either express or implied. +*/ + +#include +#include +#include +#include +#include "esp_wifi.h" +#include "esp_system.h" +#include "nvs_flash.h" +#include "esp_event.h" +#include "esp_netif.h" +#include "protocol_examples_common.h" + +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/semphr.h" +#include "freertos/queue.h" + +#include "lwip/sockets.h" +#include "lwip/dns.h" +#include "lwip/netdb.h" + +#include "esp_log.h" +#include "mqtt_client.h" +#include "driver/gpio.h" +#include "bsp.h" + +static const char *TAG = "MQTT_EXAMPLE"; + +#define BLINK_GPIO 2 +static uint8_t s_led_state = 0; + + + +/* + * @brief Event handler registered to receive MQTT events + * + * This function is called by the MQTT client event loop. + * + * @param handler_args user data registered to the event. + * @param base Event base for the handler(always MQTT Base in this example). + * @param event_id The id for the received event. + * @param event_data The data for the event, esp_mqtt_event_handle_t. + */ +static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) +{ + switch (QUISUISJE){ + case BATEAU: + mqtt_event_handler_bateau(handler_args,base,event_id,event_data); + break; + case RADIO_BATEAU: + mqtt_event_handler_radio_bateau(handler_args,base,event_id,event_data); + break; + case VOITURE: + mqtt_event_handler_voiture(handler_args,base,event_id,event_data); + break; + case RADIO_VOITURE: + mqtt_event_handler_radio_voiture(handler_args,base,event_id,event_data); + break; + default: + break; + } +} + +static void mqtt_app_start(void) +{ + esp_mqtt_client_config_t mqtt_cfg = { + .broker.address.uri = CONFIG_BROKER_URL, + }; + + + esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg); + /* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */ + esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL); + esp_mqtt_client_start(client); +//* + int msg_id; + //uint16_t count=0; + char data[10]; + while(1) + { + /*switch (QUISUISJE){ + case BATEAU: + loop_bateau(); + break; + case RADIO_BATEAU: + loop_radio_bateau(); + break; + case VOITURE: + loop_voiture(); + break; + case RADIO_VOITURE: + loop_radio_voiture(); + break; + case STARTER_VOITURE: + loop_starter_voiture(); + break; + default: + break; + }*/ + s_led_state=!s_led_state; + gpio_set_level(BLINK_GPIO, s_led_state); + sprintf(data,"%i",s_led_state); + //if(MQTT_CONNECTED) { + msg_id = esp_mqtt_client_publish(client, "/topic/qos0",data, 0, 0, 0); + //} + vTaskDelay(100 / portTICK_PERIOD_MS); + } +//*/ +} + +void app_main(void) +{ + ESP_LOGI(TAG, "[APP] Startup.."); + ESP_LOGI(TAG, "[APP] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size()); + ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version()); + + esp_log_level_set("*", ESP_LOG_INFO); + esp_log_level_set("mqtt_client", ESP_LOG_VERBOSE); + esp_log_level_set("MQTT_EXAMPLE", ESP_LOG_VERBOSE); + esp_log_level_set("TRANSPORT_BASE", ESP_LOG_VERBOSE); + esp_log_level_set("esp-tls", ESP_LOG_VERBOSE); + esp_log_level_set("TRANSPORT", ESP_LOG_VERBOSE); + esp_log_level_set("outbox", ESP_LOG_VERBOSE); + + ESP_ERROR_CHECK(nvs_flash_init()); +// ESP_ERROR_CHECK(esp_netif_init()); +// ESP_ERROR_CHECK(esp_event_loop_create_default()); + + /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig. + * Read "Establishing Wi-Fi or Ethernet Connection" section in + * examples/protocols/README.md for more information about this function. + */ + ESP_LOGI(TAG, "Example configured to blink GPIO LED!"); + //gpio_reset_pin(BLINK_GPIO); + gpio_reset_pin(15); + /* Set the GPIO as a push/pull output */ + //pio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT); + gpio_set_direction(15, GPIO_MODE_OUTPUT); + boardInit(); + setupBoard(); + loop_board(); + //ESP_ERROR_CHECK(example_connect()); + + + //esp_wifi_set_ps(WIFI_PS_NONE) ; + //mqtt_app_start(); +} diff --git a/main/bsp.c b/main/bsp.c new file mode 100644 index 0000000..1ae024d --- /dev/null +++ b/main/bsp.c @@ -0,0 +1,399 @@ +/* MQTT (over TCP) Example + + This example code is in the Public Domain (or CC0 licensed, at your option.) + + Unless required by applicable law or agreed to in writing, this + software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + CONDITIONS OF ANY KIND, either express or implied. +*/ + + +#include "bsp.h" +#define MIN_POTAR 1500 +#define MAX_POTAR 2500 + +static const char *TAG_DEBUG= "VE_DEBUG"; +model_t QUISUISJE; +int idModele; +int idGroup; +networkType_t networkType; +uint32_t minDir=MIN_POTAR,maxDir=MAX_POTAR ,minThr=MIN_POTAR,maxThr=MAX_POTAR; + +//static uint8_t led_strip_pixels[EXAMPLE_LED_NUMBERS * 3]; +ledc_channel_config_t ledc_channel[LEDC_TEST_CH_NUM] = { + { + .channel = LEDC_HS_CH0_CHANNEL, + .duty = 0, + .gpio_num = LEDC_HS_CH0_GPIO, + .speed_mode = LEDC_LS_MODE, + .hpoint = 0, + .timer_sel = LEDC_LS_TIMER, + .flags.output_invert = 0 + }, + { + .channel = LEDC_HS_CH1_CHANNEL, + .duty = 0, + .gpio_num = LEDC_HS_CH1_GPIO, + .speed_mode = LEDC_LS_MODE, + .hpoint = 0, + .timer_sel = LEDC_LS_TIMER, + .flags.output_invert = 0 + }, + { + .channel = LEDC_LS_CH2_CHANNEL, + .duty = 0, + .gpio_num = LEDC_LS_CH2_GPIO, + .speed_mode = LEDC_LS_MODE, + .hpoint = 0, + .timer_sel = LEDC_LS_TIMER, + .flags.output_invert = 0 + }, + { + .channel = LEDC_LS_CH3_CHANNEL, + .duty = 0, + .gpio_num = LEDC_LS_CH3_GPIO, + .speed_mode = LEDC_LS_MODE, + .hpoint = 0, + .timer_sel = LEDC_LS_TIMER, + .flags.output_invert = 0 + }, + }; + +void testGpio(void){ + if(gpio_get_level(TYPE)) ESP_LOGI(TAG_DEBUG, "TYPE is high"); + else ESP_LOGI(TAG_DEBUG, "TYPE is low"); + if(gpio_get_level(IN1)) ESP_LOGI(TAG_DEBUG, "IN1 is high"); + else ESP_LOGI(TAG_DEBUG, "IN1 is low"); + if(gpio_get_level(CONF1)) ESP_LOGI(TAG_DEBUG, "CONF1 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF1 is low"); + if(gpio_get_level(CONF2)) ESP_LOGI(TAG_DEBUG, "CONF2 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF2 is low"); + if(gpio_get_level(CONF3)) ESP_LOGI(TAG_DEBUG, "CONF3 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF3 is low"); + if(gpio_get_level(CONF4)) ESP_LOGI(TAG_DEBUG, "CONF4 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF4 is low"); + if(gpio_get_level(CONF5)) ESP_LOGI(TAG_DEBUG, "CONF5 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF5 is low"); + if(gpio_get_level(CONF6)) ESP_LOGI(TAG_DEBUG, "CONF6 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF6 is low"); + if(gpio_get_level(CONF7)) ESP_LOGI(TAG_DEBUG, "CONF7 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF7 is low"); + if(gpio_get_level(CONF8)) ESP_LOGI(TAG_DEBUG, "CONF8 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF8 is low"); + if(gpio_get_level(CONF9)) ESP_LOGI(TAG_DEBUG, "CONF9 is high"); + else ESP_LOGI(TAG_DEBUG, "CONF9 is low"); +} + +void testAdc(void){ + int adcValue; + getBatt(&adcValue); + ESP_LOGI(TAG_DEBUG, "getBatt is %d",adcValue); + getThr(&adcValue); + ESP_LOGI(TAG_DEBUG, "getThr is %d",adcValue); + getDir(&adcValue); + ESP_LOGI(TAG_DEBUG, "getDir is %d",adcValue); + +} + +void getIdModel(model_t type){ + idModele=0; + if(gpio_get_level(CONF2))idModele+=1; + if(gpio_get_level(CONF3))idModele+=2; + if(gpio_get_level(CONF4))idModele+=4; + if(gpio_get_level(CONF5))idModele+=8; + if(gpio_get_level(CONF6))idModele+=16; +} +void getIdGroup(){ + idGroup=0; + if(gpio_get_level(CONF7))idGroup+=1; + if(gpio_get_level(CONF8))idGroup+=2; + if(gpio_get_level(CONF9))idGroup+=4; +} +void getModel(void){ + if(gpio_get_level(TYPE)){ // RADIO + if(gpio_get_level(CONF1)) { + QUISUISJE=RADIO_BATEAU; + networkType=NETWORKBATEAU; + getIdModel(QUISUISJE); + getIdGroup(); + if(idModele==0){ + QUISUISJE=STARTER_BATEAU; + ESP_LOGI(TAG_DEBUG, "je suis STARTER_BATEAU %d groupe %d",idModele,idGroup); + } + else{ + QUISUISJE=RADIO_BATEAU; + ESP_LOGI(TAG_DEBUG, "je suis RADIO_BATEAU %d groupe %d",idModele,idGroup); + } } + else { + getIdModel(RADIO_VOITURE); + getIdGroup(); + networkType=NETWORKVOITURE; + if(idModele==0){ + QUISUISJE=STARTER_VOITURE; + ESP_LOGI(TAG_DEBUG, "je suis STARTER_VOITURE %d groupe %d",idModele,idGroup); + } + else{ + QUISUISJE=RADIO_VOITURE; + ESP_LOGI(TAG_DEBUG, "je suis RADIO_VOITURE %d groupe %d",idModele,idGroup); + } + } + } + else{ // VEHICULE + if(gpio_get_level(CONF1)){ + QUISUISJE=BATEAU; + getIdModel(QUISUISJE); + getIdGroup(); + networkType=NETWORKBATEAU; + ESP_LOGI(TAG_DEBUG, "je suis BATEAU %d groupe %d",idModele,idGroup); + } + else { + QUISUISJE=VOITURE; + networkType=NETWORKVOITURE; + getIdModel(QUISUISJE); + getIdGroup(); + ESP_LOGI(TAG_DEBUG, "je suis VOITURE %d groupe %d",idModele,idGroup); + } + } +} + + +void boardInit(void) +{ + //zero-initialize the config structure. + gpio_config_t io_conf = {}; +/* //disable interrupt + io_conf.intr_type = GPIO_INTR_DISABLE; + //set as output mode + io_conf.mode = GPIO_MODE_OUTPUT; + //bit mask of the pins that you want to set,e.g.GPIO18/19 + io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL; + //disable pull-down mode + io_conf.pull_down_en = 0; + //disable pull-up mode + io_conf.pull_up_en = 0; + //configure GPIO with the given settings + gpio_config(&io_conf); +//*/ + + //bit mask of the pins, use GPIO4/5 here + io_conf.pin_bit_mask = GPIO_INPUT_PIN_SEL; + //set as input mode + io_conf.mode = GPIO_MODE_INPUT; + //enable pull-up mode + io_conf.pull_up_en = 1; + gpio_config(&io_conf); + + getModel(); + + initWS2812(); + initMotor(); + + initAdc(); + + timerGlobal=1000/TRANSMIT_PERIOD_INTERVAL*DEFAULT_TIMER_VALUE;//initialisation du timer par défaut + //testGpio(); + //testAdc(); +} + +void setMotor(uint32_t speedA, bool directionA,uint32_t speedB, bool directionB) +{ + if(QUISUISJE==BATEAU){ + if(speedAmaxDir)maxDir=rawValue; +if(rawValuemaxThr)maxThr=rawValue; +if(rawValue +#include +#include +#include +#include "esp_wifi.h" +#include "esp_system.h" +#include "nvs_flash.h" +#include "esp_event.h" +#include "esp_netif.h" + +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/semphr.h" +#include "freertos/queue.h" +#include "freertos/portmacro.h" + +#include "lwip/sockets.h" +#include "lwip/dns.h" +#include "lwip/netdb.h" + +#include "esp_log.h" +#include "mqtt_client.h" +#include "esp_err.h" +#include "wifi.h" +#include "mqttHandler.h" +#include "loop.h" +//static const char *TAG = "mqtt_example"; + +//#define GPIO_OUTPUT_IO_0 CONFIG_GPIO_OUTPUT_0 +//#define GPIO_OUTPUT_IO_1 CONFIG_GPIO_OUTPUT_1 +//#define GPIO_OUTPUT_PIN_SEL ((1ULL<MOTOR_MAX_VALUE)M1=MOTOR_MAX_VALUE; + if(M1<-MOTOR_MAX_VALUE)M1=-MOTOR_MAX_VALUE; + M2=-(-thr-dir)*5; + if(M2>MOTOR_MAX_VALUE)M2=MOTOR_MAX_VALUE; + if(M2<-MOTOR_MAX_VALUE)M2=-MOTOR_MAX_VALUE; + if(M1>0){ + speedM1=M1; + dirM1=true; + } + else{ + speedM1=-M1; + dirM1=false; + } + if(M2>0){ + speedM2=M2; + dirM2=true; + } + else{ + speedM2=-M2; + dirM2=false; + } + setMotor(speedM1,dirM1,speedM2,dirM2); + ESP_LOGI(TAG, "DIR=%d\tTHR=%d\tM1=%d\tM2=%dspeedM1=%lu\tdirM1=%s\tspeedM2=%lu\tdirM2=%s\t", dir,thr,M1,M2,speedM1,dirM1 ? "true" : "false",speedM2,dirM2 ? "true" : "false"); + timer=0; + } + else{ + if(timer++>10){// timeout de 1 seconde + esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + state_bateau=BATEAU_SLEEP; + setMotor(0,dirM1,0,dirM2); + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + getBatt(&batt); + sprintf(battStr,"%04d",batt); + msg_id = esp_mqtt_client_publish(clientMqtt, topicBatt, battStr, 0, 1, 1); + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + } + break; + case BATEAU_SLEEP: if(dataReceived){ + esp_wifi_set_ps(WIFI_PS_NONE); + state_bateau=BATEAU_RECEIVING; + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS);// necessaire pour éviter les pb de wathdog + break; + default:esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + state_bateau=BATEAU_SLEEP; + break; + } + + } +} + +void loop_radio_bateau(void ){ + static const char *TAG = "RADIO_BATEAU"; + char topicTx[SIZE_TOPIC],topicBatt[SIZE_TOPIC],battStr[5]; + char data[10]; + int dir,thr,batt; + int msg_id; + + sprintf(topicTx,"/B/%02d/%03d/com/gazdir",idGroup,idModele); + sprintf(topicBatt,"/B/%02d/%03d/Batt/radio",idGroup,idModele); + + while(1){ + switch(state_radio_bateau){ + case RADIO_BATEAU_TRANSMITTING: + if(bateauGO){ + getDir(&dir); + getThr(&thr); + sprintf(data,"%03d;%03d;",dir,thr); + msg_id = esp_mqtt_client_publish(clientMqtt, topicTx, data, 0, 0, 0); + //ESP_LOGI(TAG, "DIR=%d\tTHR=%d\tBATT=%d", dir,thr,batt); + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + } + else{ + esp_wifi_set_ps(WIFI_PS_MIN_MODEM); + state_radio_bateau=RADIO_BATEAU_SLEEP; + getBatt(&batt); + sprintf(battStr,"%04d",batt); + msg_id = esp_mqtt_client_publish(clientMqtt, topicBatt, battStr, 0, 1, 1); + } + break; + case RADIO_BATEAU_SLEEP: if(bateauGO){ + esp_wifi_set_ps(WIFI_PS_NONE);//minimise la conso, augmente la latence + state_radio_bateau=RADIO_BATEAU_TRANSMITTING; + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS);// necessaire pour éviter les pb de wathdog + break; + default:esp_wifi_set_ps(WIFI_PS_MIN_MODEM); + state_radio_bateau=RADIO_BATEAU_SLEEP; + break; + } + + } +} + +void loop_starter_bateau(void){ + static const char *TAG = "STARTER_BATEAU"; + char topicGo[SIZE_TOPIC],topicBatt[SIZE_TOPIC],battStr[5]; + char data='0'; + int batt; + uint32_t timer=0; + int msg_id; + + sprintf(topicGo,"/B/%02d/go",idGroup); + sprintf(topicBatt,"/B/%02d/%03d/Batt/tx",idGroup,idModele); + + while(1){ + switch(state_radio_bateau){ + case RADIO_BATEAU_TRANSMITTING: + if(timer>0 ){ + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + timer--; + } + else{ + //esp_wifi_set_ps(WIFI_PS_NONE); + data='0'; + msg_id = esp_mqtt_client_publish(clientMqtt, topicGo, &data, 0, 1, 1); + state_radio_bateau=RADIO_BATEAU_SLEEP; + getBatt(&batt); + sprintf(battStr,"%04d",batt); + msg_id = esp_mqtt_client_publish(clientMqtt, topicBatt, battStr, 0, 1, 1); + } + break; + case RADIO_BATEAU_SLEEP: if(gpio_get_level(IN1)==0){ + //esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + data='1'; + msg_id = esp_mqtt_client_publish(clientMqtt, topicGo, &data, 0, 1, 1); + state_radio_bateau=RADIO_BATEAU_TRANSMITTING; + timer=timerGlobal; + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS);// necessaire pour éviter les pb de wathdog + break; + default:esp_wifi_set_ps(WIFI_PS_MIN_MODEM); + state_radio_bateau=RADIO_BATEAU_SLEEP; + break; + } + + } + +} + +void loop_voiture(void ){ + static const char *TAG = "VOITURE"; + char battStr[5],topicBatt[SIZE_TOPIC]; + char data[2]; + int dir,thr,batt; + int M1,M2; + uint32_t speedM1, speedM2; + bool dirM1,dirM2; + uint32_t timer=0; + int msg_id; + + dataReceived=0; + sprintf(topicBatt,"/V/%02d/%03d/Batt/rx",idGroup,idModele); + + while(1){ + switch(state_voiture){ + case VOITURE_RECEIVING: + if(dataReceived){ + dir=dirReceived; + thr=gazReceived; + dataReceived=0; + M1=(-thr+dir)*5; + if(M1>MOTOR_MAX_VALUE)M1=MOTOR_MAX_VALUE; + if(M1<-MOTOR_MAX_VALUE)M1=-MOTOR_MAX_VALUE; + M2=-(-thr-dir)*5; + if(M2>MOTOR_MAX_VALUE)M2=MOTOR_MAX_VALUE; + if(M2<-MOTOR_MAX_VALUE)M2=-MOTOR_MAX_VALUE; + if(M1>0){ + speedM1=M1; + dirM1=true; + } + else{ + speedM1=-M1; + dirM1=false; + } + if(M2>0){ + speedM2=M2; + dirM2=true; + } + else{ + speedM2=-M2; + dirM2=false; + } + setMotor(speedM1,dirM1,speedM2,dirM2); + //ESP_LOGI(TAG, "DIR=%d\tTHR=%d\tM1=%d\tM2=%dspeedM1=%lu\tdirM1=%s\tspeedM2=%lu\tdirM2=%s\t", dir,thr,M1,M2,speedM1,dirM1 ? "true" : "false",speedM2,dirM2 ? "true" : "false"); + timer=0; + } + else{ + if(timer++>10){// timeout de 1 seconde + esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + state_voiture=VOITURE_SLEEP; + setMotor(0,dirM1,0,dirM2); + getBatt(&batt); + sprintf(battStr,"%04d",batt); + ESP_LOGI(TAG, "battStr=%s batt=%d\t", battStr,batt); + msg_id = esp_mqtt_client_publish(clientMqtt, topicBatt, battStr, 0, 1, 1); + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + } + break; + case VOITURE_SLEEP: if(dataReceived){ + esp_wifi_set_ps(WIFI_PS_NONE); + state_voiture=VOITURE_RECEIVING; + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS);// necessaire pour éviter les pb de wathdog + break; + default:esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + state_voiture=VOITURE_SLEEP; + break; + } + + } + +} +void loop_radio_voiture(void ){ + static const char *TAG = "RADIO_VOITURE"; + char topicTx[SIZE_TOPIC],topicBatt[SIZE_TOPIC],battStr[5]; + char data[10]; + int dir,thr,batt; + int msg_id; + + sprintf(topicTx,"/V/%02d/%03d/com/gazdir",idGroup,idModele); + sprintf(topicBatt,"/V/%02d/%03d/Batt/radio",idGroup,idModele); + + while(1){ + switch(state_radio_voiture){ + case RADIO_VOITURE_TRANSMITTING: + if(voitureGO){ + getDir(&dir); + getThr(&thr); + sprintf(data,"%03d;%03d;",dir,thr); + msg_id = esp_mqtt_client_publish(clientMqtt, topicTx, data, 0, 0, 0); + //ESP_LOGI(TAG, "DIR=%d\tTHR=%d\tBATT=%d", dir,thr,batt); + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + } + else{ + esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + state_radio_voiture=RADIO_VOITURE_SLEEP; + getBatt(&batt); + sprintf(battStr,"%04d",batt); + msg_id = esp_mqtt_client_publish(clientMqtt, topicBatt, battStr, 0, 1, 1); + } + break; + case RADIO_VOITURE_SLEEP: if(voitureGO){ + esp_wifi_set_ps(WIFI_PS_NONE); + state_radio_voiture=RADIO_VOITURE_TRANSMITTING; + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS);// necessaire pour éviter les pb de wathdog + break; + default:esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + state_radio_voiture=RADIO_VOITURE_SLEEP; + break; + } + + } + +} +void loop_starter_voiture(void){ + static const char *TAG = "STARTER_VOITURE"; + char topicGo[SIZE_TOPIC],topicBatt[SIZE_TOPIC],battStr[5]; + char data='0'; + int batt; + uint32_t timer=0; + int msg_id; + + sprintf(topicGo,"/V/%02d/go",idGroup); + sprintf(topicBatt,"/V/%02d/%03d/Batt/tx",idGroup,idModele); + + while(1){ + switch(state_radio_voiture){ + case RADIO_VOITURE_TRANSMITTING: + if(timer>0 ){ + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS); + timer--; + } + else{ + //esp_wifi_set_ps(WIFI_PS_NONE); + data='0'; + msg_id = esp_mqtt_client_publish(clientMqtt, topicGo, &data, 0, 1, 1); + state_radio_voiture=RADIO_VOITURE_SLEEP; + getBatt(&batt); + sprintf(battStr,"%04d",batt); + msg_id = esp_mqtt_client_publish(clientMqtt, topicBatt, battStr, 0, 1, 1); + } + break; + case RADIO_VOITURE_SLEEP: if(gpio_get_level(IN1)==0){ + //esp_wifi_set_ps(WIFI_PS_MIN_MODEM);//minimise la conso, augmente la latence + data='1'; + msg_id = esp_mqtt_client_publish(clientMqtt, topicGo, &data, 0, 1, 1); + state_radio_voiture=RADIO_VOITURE_TRANSMITTING; + timer=timerGlobal; + } + vTaskDelay(TRANSMIT_PERIOD_INTERVAL / portTICK_PERIOD_MS);// necessaire pour éviter les pb de wathdog + break; + default:esp_wifi_set_ps(WIFI_PS_MIN_MODEM); + state_radio_voiture=RADIO_VOITURE_SLEEP; + break; + } + + } + +} + +void setupBoard(void){ + switch (QUISUISJE){ + case BATEAU: + setup_bateau(); + break; + case RADIO_BATEAU: + setup_radio_bateau(); + break; + case STARTER_BATEAU: + setup_starter_bateau(); + break; + case VOITURE: + setup_voiture(); + break; + case RADIO_VOITURE: + setup_radio_voiture(); + break; + case STARTER_VOITURE: + setup_starter_voiture(); + break; + default: + break; + } + +} +void loop_board(void){ + switch (QUISUISJE){ + case BATEAU: + loop_bateau(); + break; + case RADIO_BATEAU: + loop_radio_bateau(); + break; + case STARTER_BATEAU: + loop_starter_bateau(); + break; + case VOITURE: + loop_voiture(); + break; + case RADIO_VOITURE: + loop_radio_voiture(); + break; + case STARTER_VOITURE: + loop_starter_voiture(); + break; + default: + break; + } + +} diff --git a/main/loop.h b/main/loop.h new file mode 100644 index 0000000..2dc0fc5 --- /dev/null +++ b/main/loop.h @@ -0,0 +1,19 @@ +#ifndef LOOP_FINISTRC +#define LOOP_FINISTRC + +void setupBoard(void); +void loop_board(void); +/* +void loop_bateau(void ); +void loop_radio_bateau(void ); +void loop_voiture(void ); +void loop_radio_voiture(void ); +void loop_starter_voiture(void); + +void setup_bateau(void); +void setup_radio_bateau(void); +void setup_voiture(void); +void setup_radio_voiture(void); +void setup_starter_voiture(void); +*/ +#endif \ No newline at end of file diff --git a/main/mqttHandler.c b/main/mqttHandler.c new file mode 100644 index 0000000..e9a7a16 --- /dev/null +++ b/main/mqttHandler.c @@ -0,0 +1,425 @@ +#include "bsp.h" + +static const char *TAG = "MQTT_FINISTRC"; +static void log_error_if_nonzero(const char *message, int error_code) +{ + if (error_code != 0) { + ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code); + } +} + +void mqtt_event_handler_bateau(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) +{ + ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id); + esp_mqtt_event_handle_t event = event_data; + esp_mqtt_client_handle_t client = event->client; + int msg_id; + char message[SIZE_TOPIC]; + char *ptrData; + switch ((esp_mqtt_event_id_t)event_id) { + case MQTT_EVENT_CONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED"); + char topicTx[SIZE_TOPIC]; + sprintf(topicTx,"/B/%02d/%03d/com/gazdir",idGroup,idModele); + msg_id = esp_mqtt_client_subscribe(client, topicTx, 0); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + /* + mqtt_bat("bat_rx"); + ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id); + msg_id = esp_mqtt_client_publish(client, "/"+localId+"/quoi", "bateau", 0, 1, 0); + ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id); + + + msg_id = esp_mqtt_client_subscribe(client, "/"+localId+"/confMD", 0); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + msg_id = esp_mqtt_client_subscribe(client, "/"+localId+"/confPO", 0); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + + msg_id = esp_mqtt_client_subscribe(client, "/"+localId+"/xy", 0); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); +*/ + break; + case MQTT_EVENT_DISCONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED"); + break; + + case MQTT_EVENT_SUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id); + //msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0); + //ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id); + break; + case MQTT_EVENT_UNSUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_PUBLISHED: + ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_DATA: + ESP_LOGI(TAG, "MQTT_EVENT_DATA"); + //printf("%.*s\r\n", event->data_len, event->data); + sprintf(message,"%.*s\r\n", event->data_len, event->data); + printf(message); + dirReceived=atoi(event->data); + ptrData=strchr(message,';'); + ptrData++; + gazReceived=atoi(ptrData); + dataReceived=1; + +/* + printf("\nTOPIC=%.*s\r\n", event->topic_len, event->topic); + printf("DATA=%.*s\r\n", event->data_len, event->data); + + //s_led_state=!s_led_state; + if(event->data[0]=='0') + gpio_set_level(15, 0 ); + else + gpio_set_level(15, 1 ); +*/ + break; + case MQTT_EVENT_ERROR: + ESP_LOGI(TAG, "MQTT_EVENT_ERROR"); + if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) { + log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err); + log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err); + log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno); + ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno)); + + } + break; + default: + ESP_LOGI(TAG, "Other event id:%d", event->event_id); + break; + } +} +void mqtt_event_handler_radio_bateau(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) +{ + ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id); + esp_mqtt_event_handle_t event = event_data; + esp_mqtt_client_handle_t client = event->client; + int msg_id; + char topicGo[SIZE_TOPIC]; + switch ((esp_mqtt_event_id_t)event_id) { + case MQTT_EVENT_CONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED"); + sprintf(topicGo,"/B/%02d/go",idGroup); + msg_id = esp_mqtt_client_subscribe(client, topicGo, 1); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + break; + case MQTT_EVENT_DISCONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED"); + break; + + case MQTT_EVENT_SUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id); + //msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0); + //ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id); + break; + case MQTT_EVENT_UNSUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_PUBLISHED: + ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_DATA: + ESP_LOGI(TAG, "MQTT_EVENT_DATA"); + // printf("TOPIC=%.*s\r\n", event->topic_len, event->topic); + // printf("DATA=%.*s\r\n", event->data_len, event->data); + + //char topi[30], data[30]; + //sprintf(topi,"%.*s", event->topic_len, event->topic); + //sprintf(data,"%.*s", event->data_len, event->data); + + /* ESP_LOGI(TAG, "TOPIC=%c", topi); + ESP_LOGI(TAG, "DATA=%c", data); + if (strcmp(topi, "XY") == 0) { + // https://arduino-stackexchange-com.translate.goog/questions/1013/how-do-i-split-an-incoming-string?_x_tr_sl=auto&_x_tr_tl=fr&_x_tr_hl=fr + int id1, id2, id3; + int pos1, pos2, pos3; + char* buf = "1:90&2:80&3:180"; + int n = sscanf(buf, "%d:%d&%d:%d&%d:%d", &id1, &pos1, &id2, &pos2, &id3, &pos3); + Serial.print(F("n=")); + Serial.println(n); + Serial.print(F("id1=")); + Serial.print(id1); + Serial.print(F(", pos1=")); + Serial.println(pos1); + Serial.print(F("id2=")); + Serial.print(id2); + Serial.print(F(", pos2=")); + Serial.println(pos2); + Serial.print(F("id3=")); + Serial.print(id3); + Serial.print(F(", pos3=")); + Serial.println(pos3); + }//*/ +/* + printf("\nTOPIC=%.*s\r\n", event->topic_len, event->topic); + printf("DATA=%.*s\r\n", event->data_len, event->data); + + //s_led_state=!s_led_state; + if(event->data[0]=='0') + gpio_set_level(15, 0 ); + else + gpio_set_level(15, 1 ); +*/ + sprintf(topicGo,"/B/%02d/go",idGroup); + if (strncmp(event->topic, topicGo, event->topic_len) == 0) { + ESP_LOGI(TAG, "GO value received"); + if(event->data[0]=='0'){ + bateauGO=false; + ESP_LOGI(TAG, "GO=0 "); + } + else if(event->data[0]=='1'){ + bateauGO=true; + ESP_LOGI(TAG, "GO=1"); + } + else ESP_LOGI(TAG, "invalid GO value"); + } + break; + case MQTT_EVENT_ERROR: + ESP_LOGI(TAG, "MQTT_EVENT_ERROR"); + if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) { + log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err); + log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err); + log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno); + ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno)); + + } + break; + default: + ESP_LOGI(TAG, "Other event id:%d", event->event_id); + break; + } +} +void mqtt_event_handler_starter_bateau(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) +{ + ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id); + esp_mqtt_event_handle_t event = event_data; + esp_mqtt_client_handle_t client = event->client; + int msg_id; + char topicTimer[SIZE_TOPIC]; + switch ((esp_mqtt_event_id_t)event_id) { + case MQTT_EVENT_CONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED"); + sprintf(topicTimer,"/B/%02d/timer",idGroup); + msg_id = esp_mqtt_client_subscribe(client, topicTimer, 1); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + break; + case MQTT_EVENT_DISCONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED"); + break; + + case MQTT_EVENT_SUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_UNSUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_PUBLISHED: + ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_DATA: + ESP_LOGI(TAG, "MQTT_EVENT_DATA"); + sprintf(topicTimer,"/B/%02d/timer",idGroup); + if (strncmp(event->topic, topicTimer, event->topic_len) == 0) { + ESP_LOGI(TAG, "TIMER value received"); + int dataReceived=atoi(event->data); + if(dataReceived>0){ + timerGlobal=1000/TRANSMIT_PERIOD_INTERVAL*dataReceived; + ESP_LOGI(TAG, "value received=%d ,timerGlobal= %d",dataReceived,timerGlobal); + } + else ESP_LOGI(TAG, "invalid timer value"); + } + break; + case MQTT_EVENT_ERROR: + ESP_LOGI(TAG, "MQTT_EVENT_ERROR"); + if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) { + log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err); + log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err); + log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno); + ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno)); + + } + break; + default: + ESP_LOGI(TAG, "Other event id:%d", event->event_id); + break; + } +} +void mqtt_event_handler_voiture(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) +{ + ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id); + esp_mqtt_event_handle_t event = event_data; + esp_mqtt_client_handle_t client = event->client; + int msg_id; + char topicTx[SIZE_TOPIC]; + char *ptrData,message[SIZE_TOPIC]; + + switch ((esp_mqtt_event_id_t)event_id) { + case MQTT_EVENT_CONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED"); + sprintf(topicTx,"/V/%02d/%03d/com/gazdir",idGroup,idModele); + msg_id = esp_mqtt_client_subscribe(client, topicTx, 0); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + + break; + case MQTT_EVENT_DISCONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED"); + break; + + case MQTT_EVENT_SUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_UNSUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_PUBLISHED: + ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_DATA: + ESP_LOGI(TAG, "MQTT_EVENT_DATA"); + printf("%.*s\r\n", event->data_len, event->data); + sprintf(message,"%.*s\r\n", event->data_len, event->data); + dirReceived=atoi(event->data); + ptrData=strchr(message,';'); + ptrData++; + gazReceived=atoi(ptrData); + dataReceived=1; + break; + case MQTT_EVENT_ERROR: + ESP_LOGI(TAG, "MQTT_EVENT_ERROR"); + if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) { + log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err); + log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err); + log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno); + ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno)); + + } + break; + default: + ESP_LOGI(TAG, "Other event id:%d", event->event_id); + break; + } +} +void mqtt_event_handler_radio_voiture(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) +{ + ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id); + esp_mqtt_event_handle_t event = event_data; + esp_mqtt_client_handle_t client = event->client; + int msg_id; + char topicGo[SIZE_TOPIC]; + + switch ((esp_mqtt_event_id_t)event_id) { + case MQTT_EVENT_CONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED"); + sprintf(topicGo,"/V/%02d/go",idGroup); + msg_id = esp_mqtt_client_subscribe(client, topicGo, 1); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + break; + case MQTT_EVENT_DISCONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED"); + break; + + case MQTT_EVENT_SUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_UNSUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_PUBLISHED: + ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_DATA: + ESP_LOGI(TAG, "MQTT_EVENT_DATA"); + sprintf(topicGo,"/V/%02d/go",idGroup); + if (strncmp(event->topic, topicGo, event->topic_len) == 0) { + ESP_LOGI(TAG, "GO value received"); + if(event->data[0]=='0'){ + voitureGO=false; + ESP_LOGI(TAG, "GO=0 "); + } + else if(event->data[0]=='1'){ + voitureGO=true; + ESP_LOGI(TAG, "GO=1"); + } + else ESP_LOGI(TAG, "invalid GO value"); + } + + break; + case MQTT_EVENT_ERROR: + ESP_LOGI(TAG, "MQTT_EVENT_ERROR"); + if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) { + log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err); + log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err); + log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno); + ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno)); + + } + break; + default: + ESP_LOGI(TAG, "Other event id:%d", event->event_id); + break; + } +} +void mqtt_event_handler_starter_voiture(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) +{ + ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id); + esp_mqtt_event_handle_t event = event_data; + esp_mqtt_client_handle_t client = event->client; + int msg_id; + char topicTimer[SIZE_TOPIC]; + switch ((esp_mqtt_event_id_t)event_id) { + case MQTT_EVENT_CONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED"); + sprintf(topicTimer,"/V/%02d/timer",idGroup); + msg_id = esp_mqtt_client_subscribe(client, topicTimer, 1); + ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); + break; + case MQTT_EVENT_DISCONNECTED: + ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED"); + break; + + case MQTT_EVENT_SUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_UNSUBSCRIBED: + ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_PUBLISHED: + ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id); + break; + case MQTT_EVENT_DATA: + ESP_LOGI(TAG, "MQTT_EVENT_DATA"); + sprintf(topicTimer,"/V/%02d/timer",idGroup); + if (strncmp(event->topic, topicTimer, event->topic_len) == 0) { + ESP_LOGI(TAG, "TIMER value received"); + int dataReceived=atoi(event->data); + if(dataReceived>0){ + timerGlobal=1000/TRANSMIT_PERIOD_INTERVAL*dataReceived; + ESP_LOGI(TAG, "timerGlobal= %d",timerGlobal); + } + else ESP_LOGI(TAG, "invalid timer value"); + } + break; + case MQTT_EVENT_ERROR: + ESP_LOGI(TAG, "MQTT_EVENT_ERROR"); + if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) { + log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err); + log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err); + log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno); + ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno)); + + } + break; + default: + ESP_LOGI(TAG, "Other event id:%d", event->event_id); + break; + } +} +/* +void mqtt_bat(char ouca) { + int adcValue; + getBatt(&adcValue); + msg_id = esp_mqtt_client_publish(client, "/"+localId +"/"+ ouca, adcValue, 0, 1, 0); + ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id); +}//*/ \ No newline at end of file diff --git a/main/mqttHandler.h b/main/mqttHandler.h new file mode 100644 index 0000000..b5a8f01 --- /dev/null +++ b/main/mqttHandler.h @@ -0,0 +1,13 @@ +#ifndef MQTT_FINISTRC +#define MQTT_FINISTRC + +#include "bsp.h" + +void mqtt_event_handler_bateau(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data); +void mqtt_event_handler_radio_bateau(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data); +void mqtt_event_handler_voiture(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data); +void mqtt_event_handler_radio_voiture(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data); +void mqtt_event_handler_starter_voiture(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data); +void mqtt_event_handler_starter_bateau(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data); + +#endif \ No newline at end of file diff --git a/main/wifi.c b/main/wifi.c new file mode 100644 index 0000000..d4393a7 --- /dev/null +++ b/main/wifi.c @@ -0,0 +1,174 @@ +/* WiFi station Example + + This example code is in the Public Domain (or CC0 licensed, at your option.) + + Unless required by applicable law or agreed to in writing, this + software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + CONDITIONS OF ANY KIND, either express or implied. +*/ +#include "bsp.h" + + + +/* The examples use WiFi configuration that you can set via project configuration menu + + If you'd rather not, just change the below entries to strings with + the config you want - ie #define EXAMPLE_WIFI_SSID "mywifissid" +*/ +#define BATEAU_ESP_WIFI_SSID "APbateaux" +#define BATEAU_ESP_WIFI_PASS "finistrc" +#define VOITURE_ESP_WIFI_SSID "APvoitures" +#define VOITURE_ESP_WIFI_PASS "finistrc" +#define EXAMPLE_ESP_MAXIMUM_RETRY 10 + +#if CONFIG_ESP_WPA3_SAE_PWE_HUNT_AND_PECK +#define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_HUNT_AND_PECK +#define EXAMPLE_H2E_IDENTIFIER "" +#elif CONFIG_ESP_WPA3_SAE_PWE_HASH_TO_ELEMENT +#define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_HASH_TO_ELEMENT +#define EXAMPLE_H2E_IDENTIFIER CONFIG_ESP_WIFI_PW_ID +#elif CONFIG_ESP_WPA3_SAE_PWE_BOTH +#define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_BOTH +#define EXAMPLE_H2E_IDENTIFIER CONFIG_ESP_WIFI_PW_ID +#endif +#if CONFIG_ESP_WIFI_AUTH_OPEN +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_OPEN +#elif CONFIG_ESP_WIFI_AUTH_WEP +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WEP +#elif CONFIG_ESP_WIFI_AUTH_WPA_PSK +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_PSK +#elif CONFIG_ESP_WIFI_AUTH_WPA2_PSK +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_PSK +#elif CONFIG_ESP_WIFI_AUTH_WPA_WPA2_PSK +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_WPA2_PSK +#elif CONFIG_ESP_WIFI_AUTH_WPA3_PSK +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA3_PSK +#elif CONFIG_ESP_WIFI_AUTH_WPA2_WPA3_PSK +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_WPA3_PSK +#elif CONFIG_ESP_WIFI_AUTH_WAPI_PSK +#define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WAPI_PSK +#endif + +/* FreeRTOS event group to signal when we are connected*/ +static EventGroupHandle_t s_wifi_event_group; + +/* The event group allows multiple bits for each event, but we only care about two events: + * - we are connected to the AP with an IP + * - we failed to connect after the maximum amount of retries */ +#define WIFI_CONNECTED_BIT BIT0 +#define WIFI_FAIL_BIT BIT1 + +static const char *TAG = "wifi station"; + +static int s_retry_num = 0; + + +static void event_handler(void* arg, esp_event_base_t event_base, + int32_t event_id, void* event_data) +{ + if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) { + esp_wifi_connect(); + } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) { + if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY) { + esp_wifi_connect(); + s_retry_num++; + ESP_LOGI(TAG, "retry to connect to the AP"); + } else { + xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT); + } + ESP_LOGI(TAG,"connect to the AP fail"); + } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) { + ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data; + ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip)); + s_retry_num = 0; + xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT); + } +} + +void wifi_init_sta(uint32_t networkConfig) +{ + s_wifi_event_group = xEventGroupCreate(); +ESP_LOGI(TAG, "try connect wifi"); + ESP_ERROR_CHECK(esp_netif_init()); +ESP_LOGI(TAG, "try connect wifi 2"); + ESP_ERROR_CHECK(esp_event_loop_create_default()); + esp_netif_create_default_wifi_sta(); +ESP_LOGI(TAG, "try connect wifi 3"); + wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); + ESP_ERROR_CHECK(esp_wifi_init(&cfg)); +ESP_LOGI(TAG, "try connect wifi 4"); + esp_event_handler_instance_t instance_any_id; + esp_event_handler_instance_t instance_got_ip; + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + ESP_EVENT_ANY_ID, + &event_handler, + NULL, + &instance_any_id)); + ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, + IP_EVENT_STA_GOT_IP, + &event_handler, + NULL, + &instance_got_ip)); + + wifi_config_t * wifi_config; + wifi_config_t wifi_config_bateau = { + .sta = { + .ssid = BATEAU_ESP_WIFI_SSID, + .password = BATEAU_ESP_WIFI_PASS, + /* Authmode threshold resets to WPA2 as default if password matches WPA2 standards (pasword len => 8). + * If you want to connect the device to deprecated WEP/WPA networks, Please set the threshold value + * to WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK and set the password with length and format matching to + * WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK standards. + */ + //.threshold.authmode = ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD, + //.sae_pwe_h2e = ESP_WIFI_SAE_MODE, + //.sae_h2e_identifier = EXAMPLE_H2E_IDENTIFIER, + }, + }; + wifi_config_t wifi_config_voiture = { + .sta = { + .ssid = VOITURE_ESP_WIFI_SSID, + .password = VOITURE_ESP_WIFI_PASS, + /* Authmode threshold resets to WPA2 as default if password matches WPA2 standards (pasword len => 8). + * If you want to connect the device to deprecated WEP/WPA networks, Please set the threshold value + * to WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK and set the password with length and format matching to + * WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK standards. + */ + //.threshold.authmode = ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD, + //.sae_pwe_h2e = ESP_WIFI_SAE_MODE, + //.sae_h2e_identifier = EXAMPLE_H2E_IDENTIFIER, + }, + }; + if(networkConfig==NETWORKBATEAU) + wifi_config=&wifi_config_bateau; + if(networkConfig==NETWORKVOITURE) + wifi_config=&wifi_config_voiture; + + ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) ); + ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, wifi_config) ); + ESP_ERROR_CHECK(esp_wifi_start() ); + + ESP_LOGI(TAG, "wifi_init_sta finished."); + + /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum + * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */ + EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, + WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, + pdFALSE, + pdFALSE, + portMAX_DELAY); + + /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually + * happened. */ + if (bits & WIFI_CONNECTED_BIT) { + ESP_LOGI(TAG, "connected to ap SSID:%s password:%s", + wifi_config->sta.ssid, wifi_config->sta.password); + } else if (bits & WIFI_FAIL_BIT) { + ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s", + wifi_config->sta.ssid, wifi_config->sta.password); + vTaskDelay(1000 / portTICK_PERIOD_MS); + esp_restart(); + } else { + ESP_LOGE(TAG, "UNEXPECTED EVENT"); + } +} \ No newline at end of file diff --git a/main/wifi.h b/main/wifi.h new file mode 100644 index 0000000..1d70865 --- /dev/null +++ b/main/wifi.h @@ -0,0 +1,26 @@ +#ifndef WIFI_FINISTRC +#define WIFI_FINISTRC + +#include "bsp.h" + +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/event_groups.h" +#include "esp_system.h" +#include "esp_wifi.h" +#include "esp_event.h" +#include "esp_log.h" +#include "nvs_flash.h" + +#include "lwip/err.h" +#include "lwip/sys.h" + +typedef enum { + NETWORKBATEAU, + NETWORKVOITURE +} networkType_t; + +void wifi_init_sta(uint32_t networkConfig); + +#endif \ No newline at end of file