400 lines
13 KiB
C
400 lines
13 KiB
C
/* 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);
|
|
}
|
|
|