FinistRC/mqtt-rc
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Version AP avec mdp, bateaux en régime TOR

Browse Source
This commit is contained in:
Vincent ESCARGUEL
2024-05-18 15:17:13 +02:00
commit 21b326092e
11 changed files with 1886 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
main/CMakeLists.txt Normal file
View File

@@ -0,0 +1,2 @@
idf_component_register(SRCS "loop.c" "mqttHandler.c" "wifi.c" "bsp.c" "app_main.c"
INCLUDE_DIRS ".")

13
main/Kconfig.projbuild Normal file
View File

@@ -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

155
main/app_main.c Normal file
View File

@@ -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 <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#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();
}

399
main/bsp.c Normal file
View File

@@ -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(speedA<SEUIL_MOTEUR){
gpio_set_level(M1A,0);
gpio_set_level(M1B,0);
}
else if(directionA){
gpio_set_level(M1A,1);
gpio_set_level(M1B,0);
}
else {
gpio_set_level(M1A,0);
gpio_set_level(M1B,1);
}
if(speedB<SEUIL_MOTEUR){
gpio_set_level(M2A,0);
gpio_set_level(M2B,0);
}
else if(directionB){
gpio_set_level(M2A,1);
gpio_set_level(M2B,0);
}
else {
gpio_set_level(M2A,0);
gpio_set_level(M2B,1);
}
}
else{
if(directionA){
ledc_set_duty(ledc_channel[0].speed_mode, ledc_channel[0].channel, speedA);
ledc_update_duty(ledc_channel[0].speed_mode, ledc_channel[0].channel);
ledc_set_duty(ledc_channel[1].speed_mode, ledc_channel[1].channel, 0);
ledc_update_duty(ledc_channel[1].speed_mode, ledc_channel[1].channel);
}
else{
ledc_set_duty(ledc_channel[0].speed_mode, ledc_channel[0].channel, 0);
ledc_update_duty(ledc_channel[0].speed_mode, ledc_channel[0].channel);
ledc_set_duty(ledc_channel[1].speed_mode, ledc_channel[1].channel, speedA);
ledc_update_duty(ledc_channel[1].speed_mode, ledc_channel[1].channel);
}
if(directionB){
ledc_set_duty(ledc_channel[2].speed_mode, ledc_channel[2].channel, speedB);
ledc_update_duty(ledc_channel[2].speed_mode, ledc_channel[2].channel);
ledc_set_duty(ledc_channel[3].speed_mode, ledc_channel[3].channel, 0);
ledc_update_duty(ledc_channel[3].speed_mode, ledc_channel[3].channel);
}
else{
ledc_set_duty(ledc_channel[2].speed_mode, ledc_channel[2].channel, 0);
ledc_update_duty(ledc_channel[2].speed_mode, ledc_channel[2].channel);
ledc_set_duty(ledc_channel[3].speed_mode, ledc_channel[3].channel, speedB);
ledc_update_duty(ledc_channel[3].speed_mode, ledc_channel[3].channel);
}
}
}
void initMotor(void)
{
int ch;
if(QUISUISJE==VOITURE){ /*
* Prepare and set configuration of timers
* that will be used by LED Controller
*/
ledc_timer_config_t ledc_timerM1 = {
.duty_resolution = LEDC_TIMER_10_BIT, // resolution of PWM duty
.freq_hz = 250, // frequency of PWM signal
.speed_mode = LEDC_HS_MODE, // timer mode
.timer_num = LEDC_HS_TIMER, // timer index
.clk_cfg = LEDC_AUTO_CLK, // Auto select the source clock
};
ledc_timer_config_t ledc_timerM2 = {
.duty_resolution = LEDC_TIMER_10_BIT, // resolution of PWM duty
.freq_hz = 250, // frequency of PWM signal
.speed_mode = LEDC_LS_MODE, // timer mode
.timer_num = LEDC_LS_TIMER, // timer index
.clk_cfg = LEDC_AUTO_CLK, // Auto select the source clock
};
// Set configuration of timer0 for high speed channels
ledc_timer_config(&ledc_timerM1);
// Prepare and set configuration of timer1 for low speed channels
//ledc_timer.speed_mode = LEDC_HS_MODE;
//ledc_timer.timer_num = LEDC_HS_TIMER;
ledc_timer_config(&ledc_timerM2);
/*
* Prepare individual configuration
* for each channel of LED Controller
* by selecting:
* - controller's channel number
* - output duty cycle, set initially to 0
* - GPIO number where LED is connected to
* - speed mode, either high or low
* - timer servicing selected channel
* Note: if different channels use one timer,
* then frequency and bit_num of these channels
* will be the same
*/
// Set LED Controller with previously prepared configuration
for (ch = 0; ch < LEDC_TEST_CH_NUM; ch++) {
ledc_channel_config(&ledc_channel[ch]);
}
}
else{
gpio_reset_pin(M1A);
gpio_set_direction(M1A, GPIO_MODE_OUTPUT);
gpio_reset_pin(M1B);
gpio_set_direction(M1B, GPIO_MODE_OUTPUT);
gpio_reset_pin(M2A);
gpio_set_direction(M2A, GPIO_MODE_OUTPUT);
gpio_reset_pin(M2B);
gpio_set_direction(M2B, GPIO_MODE_OUTPUT);
}
setMotor(0,true,0,true);
}
adc_oneshot_unit_handle_t adc1_handle;
void initAdc(void)
{
adc_oneshot_unit_init_cfg_t init_config1 = {
.unit_id = ADC_UNIT_1,
};
ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config1, &adc1_handle));
//-------------ADC1 Config---------------//
adc_oneshot_chan_cfg_t config = {
.bitwidth = ADC_BITWIDTH_DEFAULT,
.atten = EXAMPLE_ADC_ATTEN,
};
(adc_oneshot_config_channel(adc1_handle, BATT_ADC, &config));
(adc_oneshot_config_channel(adc1_handle, THR_ADC, &config));
(adc_oneshot_config_channel(adc1_handle, DIR_ADC, &config));
}
void initWS2812(void)
{
/*
// ESP_LOGI(TAG, "Create RMT TX channel");
rmt_channel_handle_t led_chan = NULL;
rmt_tx_channel_config_t tx_chan_config = {
.clk_src = RMT_CLK_SRC_DEFAULT, // select source clock
.gpio_num = RMT_LED_STRIP_GPIO_NUM,
.mem_block_symbols = 64, // increase the block size can make the LED less flickering
.resolution_hz = RMT_LED_STRIP_RESOLUTION_HZ,
.trans_queue_depth = 4, // set the number of transactions that can be pending in the background
};
ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &led_chan));
// ESP_LOGI(TAG, "Install led strip encoder");
rmt_encoder_handle_t led_encoder = NULL;
led_strip_encoder_config_t encoder_config = {
.resolution = RMT_LED_STRIP_RESOLUTION_HZ,
};
ESP_ERROR_CHECK(rmt_new_led_strip_encoder(&encoder_config, &led_encoder));
//ESP_LOGI(TAG, "Enable RMT TX channel");
ESP_ERROR_CHECK(rmt_enable(led_chan));
//ESP_LOGI(TAG, "Start LED rainbow chase");
rmt_transmit_config_t tx_config = {
.loop_count = 0, // no transfer loop
};
//*/
}
void getBattRaw(int *value){
adc_oneshot_read(adc1_handle, BATT_ADC, value);
}
void getDirRaw(int *value){
adc_oneshot_read(adc1_handle, DIR_ADC, value);
}
void getThrRaw(int *value){
adc_oneshot_read(adc1_handle, THR_ADC, value);
}
// Normalized value in mV
void getBatt(int *value){
int rawValue;
getBattRaw( &rawValue);
*value=(int)(rawValue*3.5);//scale TBD
}
// Normalized value between -100 and +100
void getDir(int *value){
int rawValue;
getDirRaw( &rawValue);
if(rawValue>maxDir)maxDir=rawValue;
if(rawValue<minDir) minDir=rawValue;
*value=-100 + (rawValue-minDir)*200/(maxDir-minDir);
}
// Normalized value between -100 and +100
void getThr(int *value){
int rawValue;
getThrRaw( &rawValue);
if(rawValue>maxThr)maxThr=rawValue;
if(rawValue<minThr)minThr=rawValue;
*value=-100 + (rawValue-minThr)*200/(maxThr-minThr);
}

180
main/bsp.h Normal file
View File

@@ -0,0 +1,180 @@
/* 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.
*/
#ifndef BSP_FINISTRC
#define BSP_FINISTRC
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#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<<GPIO_OUTPUT_IO_0) | (1ULL<<GPIO_OUTPUT_IO_1))
//configuration pins section
#include "driver/gpio.h"
#define TYPE (36)
#define IN1 (39)
#define CONF1 (22)
#define CONF2 (21)
#define CONF3 (19)
#define CONF4 (18)
#define CONF5 (5)
#define CONF6 (17)
#define CONF7 (16)
#define CONF8 (4)
#define CONF9 (2)
#define M1A (25)
#define M1B (32)
#define M2A (27)
#define M2B (26)
#define GPIO_INPUT_PIN_SEL ((1ULL<<TYPE) | (1ULL<<IN1) | (1ULL<<CONF1) | (1ULL<<CONF2) | (1ULL<<CONF3) | (1ULL<<CONF4) | (1ULL<<CONF5) | (1ULL<<CONF6) | (1ULL<<CONF7) | (1ULL<<CONF8) | (1ULL<<CONF9))
//end of configuration pins section
//addressable LED section
#include "driver/rmt_tx.h"
//#include "led_strip_encoder.h"
#define RMT_LED_STRIP_RESOLUTION_HZ 10000000 // 10MHz resolution, 1 tick = 0.1us (led strip needs a high resolution)
#define RMT_LED_STRIP_GPIO_NUM 0
#define EXAMPLE_LED_NUMBERS 24
extern uint8_t led_strip_pixels[EXAMPLE_LED_NUMBERS * 3];
//end of addressable LED section
//motor section
#include "driver/ledc.h"
#define LEDC_HS_TIMER LEDC_TIMER_0
#define LEDC_HS_MODE LEDC_HIGH_SPEED_MODE
#define LEDC_HS_CH0_GPIO (25)
#define LEDC_HS_CH0_CHANNEL LEDC_CHANNEL_0
#define LEDC_HS_CH1_GPIO (32)
#define LEDC_HS_CH1_CHANNEL LEDC_CHANNEL_1
#define LEDC_LS_TIMER LEDC_TIMER_1
#define LEDC_LS_MODE LEDC_LOW_SPEED_MODE
#define LEDC_LS_CH2_GPIO (27)
#define LEDC_LS_CH2_CHANNEL LEDC_CHANNEL_2
#define LEDC_LS_CH3_GPIO (26)
#define LEDC_LS_CH3_CHANNEL LEDC_CHANNEL_3
#define MOTOR_MAX_VALUE 1023
#define SEUIL_MOTEUR 200
#define LEDC_TEST_CH_NUM (4)
#define LEDC_TEST_DUTY (4000)
#define LEDC_TEST_FADE_TIME (3000)
//end of motor section
//adc section
#include "esp_adc/adc_oneshot.h"
//#include "esp_adc/adc_cali.h"
//#include "esp_adc/adc_cali_scheme.h"
#define BATT_ADC ADC_CHANNEL_5
#define THR_ADC ADC_CHANNEL_6
#define DIR_ADC ADC_CHANNEL_7
#define EXAMPLE_ADC_ATTEN ADC_ATTEN_DB_11
//end of adc section
//FinistRC section
// URL des broker, pour l'instant ce sont les memes
#define CONFIG_BROKER_URL_BATEAU "mqtt://openwrt.lan"
#define CONFIG_BROKER_URL_VOITURE "mqtt://openwrt.lan"
#define DEFAULT_TIMER_VALUE 180 // 3 minutes = 180 secondes
#define TRANSMIT_PERIOD_INTERVAL 100 // 100 millisecondes entre les trames
#define SIZE_TOPIC 25 // longueur des noms des topic
#define TOPIC_TIMER_BATEAU "/B/timer"
typedef enum {
BATEAU,
RADIO_BATEAU,
VOITURE,
RADIO_VOITURE,
STARTER_VOITURE,
STARTER_BATEAU
} model_t;
typedef enum {
BATEAU_RECEIVING,
BATEAU_SLEEP
} state_bateau_t;
typedef enum {
RADIO_BATEAU_TRANSMITTING,
RADIO_BATEAU_SLEEP
} state_radio_bateau_t;
typedef enum {
VOITURE_RECEIVING,
VOITURE_SLEEP
} state_voiture_t;
typedef enum {
RADIO_VOITURE_TRANSMITTING,
RADIO_VOITURE_SLEEP
} state_radio_voiture_t;
extern model_t QUISUISJE;
extern int idModele;
extern int idGroup;
extern networkType_t networkType;
extern state_bateau_t state_bateau;
extern state_radio_bateau_t state_radio_bateau;
extern state_voiture_t state_voiture;
extern state_radio_voiture_t state_radio_voiture;
extern int timerGlobal;
extern bool voitureGO;
extern bool bateauGO;
extern int dataReceived,gazReceived,dirReceived;
extern esp_mqtt_client_handle_t clientMqtt;
// End of FinistRC section
void boardInit(void);
void initWS2812(void);
void initMotor(void);
void initAdc(void);
void setMotor(uint32_t speedA, bool directionA,uint32_t speedB, bool directionB);
void getBatt(int *value);
void getDir(int *value);
void getThr(int *value);
#endif

480
main/loop.c Normal file
View File

@@ -0,0 +1,480 @@
#include "bsp.h"
int timerGlobal;
state_bateau_t state_bateau;
state_radio_bateau_t state_radio_bateau;
state_voiture_t state_voiture;
state_radio_voiture_t state_radio_voiture;
esp_mqtt_client_handle_t clientMqtt;
int dataReceived,gazReceived,dirReceived;
bool voitureGO;
bool bateauGO;
// WIFI_PS_NONE WIFI_PS_MIN_MODEM
void setup_bateau(void){
wifi_init_sta(networkType);
esp_mqtt_client_config_t mqtt_cfg = {
.broker.address.uri = CONFIG_BROKER_URL_BATEAU,
};
clientMqtt = 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(clientMqtt, ESP_EVENT_ANY_ID, mqtt_event_handler_bateau, NULL);
esp_mqtt_client_start(clientMqtt);
}
void setup_radio_bateau(void){
wifi_init_sta(networkType);
esp_mqtt_client_config_t mqtt_cfg = {
.broker.address.uri = CONFIG_BROKER_URL_BATEAU,
};
clientMqtt = 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(clientMqtt, ESP_EVENT_ANY_ID, mqtt_event_handler_radio_bateau, NULL);
esp_mqtt_client_start(clientMqtt);
}
void setup_starter_bateau(void){
wifi_init_sta(networkType);
esp_mqtt_client_config_t mqtt_cfg = {
.broker.address.uri = CONFIG_BROKER_URL_BATEAU,
};
clientMqtt = 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(clientMqtt, ESP_EVENT_ANY_ID, mqtt_event_handler_starter_bateau, NULL);
esp_mqtt_client_start(clientMqtt);
bateauGO=false;
}
void setup_voiture(void){
/*
static const char *TAG = "BATEAU";
int i;
while(1)
{
for(i=0;i<1001;i+=100)
{
setMotor(i,false,i,true);
ESP_LOGI(TAG, "speed=%d", i);
vTaskDelay(2000 / portTICK_PERIOD_MS);
}
for(i=0;i<1001;i+=100)
{
setMotor(i,true,i,false);
ESP_LOGI(TAG, "speed=%d", i);
vTaskDelay(2000 / portTICK_PERIOD_MS);
}
}//*/
wifi_init_sta(networkType);
esp_mqtt_client_config_t mqtt_cfg = {
.broker.address.uri = CONFIG_BROKER_URL_VOITURE,
};
clientMqtt = 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(clientMqtt, ESP_EVENT_ANY_ID, mqtt_event_handler_voiture, NULL);
esp_mqtt_client_start(clientMqtt);
voitureGO=false;
// setMotor(6000,false,6000,true);;
}
void setup_radio_voiture(void){
wifi_init_sta(networkType);
esp_mqtt_client_config_t mqtt_cfg = {
.broker.address.uri = CONFIG_BROKER_URL_VOITURE,
};
clientMqtt = 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(clientMqtt, ESP_EVENT_ANY_ID, mqtt_event_handler_radio_voiture, NULL);
esp_mqtt_client_start(clientMqtt);
voitureGO=false;
}
void setup_starter_voiture(void){
wifi_init_sta(networkType);
esp_mqtt_client_config_t mqtt_cfg = {
.broker.address.uri = CONFIG_BROKER_URL_VOITURE,
};
clientMqtt = 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(clientMqtt, ESP_EVENT_ANY_ID, mqtt_event_handler_starter_voiture, NULL);
esp_mqtt_client_start(clientMqtt);
voitureGO=false;
}
void loop_bateau(void ){
static const char *TAG = "BATEAU";
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,"/B/%02d/%03d/Batt/rx",idGroup,idModele);
while(1){
switch(state_bateau){
case BATEAU_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_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;
}
}

19
main/loop.h Normal file
View File

@@ -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

425
main/mqttHandler.c Normal file
View File

@@ -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);
}//*/

13
main/mqttHandler.h Normal file
View File

@@ -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

174
main/wifi.c Normal file
View File

@@ -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");
}
}

26
main/wifi.h Normal file
View File

@@ -0,0 +1,26 @@
#ifndef WIFI_FINISTRC
#define WIFI_FINISTRC
#include "bsp.h"
#include <string.h>
#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