Question sur <ESPAsyncWebServer.h>

el_gringo · June 18, 2023, 6:37pm

Bonjour,

Dans le programme suivant tout fonctionne. Cependant à ce niveau là (/readTurnout) je reçois par exemple 2400 sous forme de string. Du coup, comme pour les autres données que je reçois je les convertis en integer avec toInt(). Le problème (ou la question que j'ai) est que pour ce cas précis je n'ai pas besoin de faire un toInt(). Si je le fais je ne peux plus récupérer la variable.

Y-a-t-il une explication?

merci.

server.on("/readTurnout", HTTP_POST, [](AsyncWebServerRequest *request)
  {
    String turnoutR;
        if (request->hasParam("numTurnout",true)) {
      turnoutR= request->getParam("numTurnout",true)->value();
    //numDirection=direction.toInt();
    turnout = turnoutR.toInt();
    //direction = directionR;
      Serial.print(turnout);
      Serial.println();
  }
   request->send(204);
  });

 #include <Arduino.h>
#include "driver/ledc.h"
#include <ESPAsyncWebServer.h>
#include <SPIFFS.h>

// -----------------------------------------------WEBSERVER
AsyncWebServer server(80);

const char* ssid = "REDACTED";
const char* password = "REDACTED";
int numLoco; int numSpeed; int numDirection;

//-----------------------------------------------INTERRUPTION

const int BUFFER_SIZE = 100;
char buf[BUFFER_SIZE];
static int trame[5];

// DEFINITION DE LA SORTIE PWM  
#define DCC_PIN 22
#define PWM_PIN 23  // Sortie du signal DCC envoi courant

// ON DEFINIT LES PULSIONS PWM
const uint16_t DCC_BIT_1_FREQ =8621; // 116 microsecondes
const uint16_t DCC_BIT_0_FREQ = 5000; // 200 microsecondes
const int dcc_pin_channel = 0; // CANAL PWM 0
const int dcc_sig_resolution =1; // on est sur 1 bit de resolution 2^1 2 valeurs possibles
const int dcc_sig_duty=1; // on est sur 1 bit de resolution 1/2^1 50%
//initialisation de la frequence
uint32_t dcc_sig_freq=DCC_BIT_1_FREQ;
static uint32_t old_dcc_sig_freq;


static uint64_t v; // variable de 48 bits
static byte pointer;
; // nb de bits
static byte DccBit; // valeur du bit
static uint64_t DccBitShift=0b100000000000000000000000000000000000000000000000;//((uint64_t) -1 )>> ((uint64_t)0 - 47); // creation d un masque pou egrener les bits

// declaration des voids
void dcc_sig_isr(); // fonction d interruption
void setup_ledc(void); // setup du PWM duty 50% sur 1 de precision il y a 2 periodes : 116microsecondes et 200 microsecondes
//void SpeedAndDir();


static byte speed; //Speedy;
static byte vecSpeed;//
static byte dccSpeed;
static byte loco;//addr;
static byte vecLoco;
static bool direction;
static byte action;
static int fonction;
static int turnout;


void setup(){

    Serial.begin(460800);
    delay(1000);

      //----------------------------------------------------SPIFFS
  if(!SPIFFS.begin())
  {
    Serial.println("Erreur SPIFFS...");
    return;
  }

  File root = SPIFFS.open("/");
  File file = root.openNextFile();

  while(file)
  {
    Serial.print("File: ");
    Serial.println(file.name());
    file.close();
    file = root.openNextFile();
  }

  
  //----------------------------------------------------WIFI
  WiFi.begin(ssid, password);
	Serial.print("Tentative de connexion...");
	
	while(WiFi.status() != WL_CONNECTED)
	{
		Serial.print(".");
		delay(100);
	}
	
	Serial.println("\n");
	Serial.println("Connexion etablie!");
	Serial.print("Adresse IP: ");
	Serial.println(WiFi.localIP());


  //----------------------------------------------------SERVER
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request)
  {
    request->send(SPIFFS, "/index.html", "text/html");
  });

  server.on("/style.css", HTTP_GET, [](AsyncWebServerRequest *request)
  {
    request->send(SPIFFS, "/style.css", "text/css");
  });

  server.on("/script.js", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(SPIFFS, "/script.js", "text/javascript");
  });

   server.on("/rangeslider.js", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(SPIFFS, "/rangeslider.js", "text/javascript");
  });

  server.on("/jquery-3.6.0.min.js", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(SPIFFS, "/jquery-3.6.0.min.js", "text/javascript");
  });

  server.on("/readTrame", HTTP_POST, [](AsyncWebServerRequest *request)
  {


    String locoR; String speedR; String directionR; String fonctionR;

    if (request->hasParam("numLoco",true)) {
      locoR = request->getParam("numLoco",true)->value();
      //numLoco=loco.toInt();
     // numLoco=locoR.toInt();
      loco=byte(locoR.toInt());
      Serial.print(loco);
       Serial.println("\t");
    }

    if (request->hasParam("numSpeed",true)) {
    speedR = request->getParam("numSpeed",true)->value();
       //numSpeed=speed.toInt();
       //numSpeed=speedR.toInt();
       speed=byte(speedR.toInt());
        Serial.print(speed);
      Serial.print("\t");
   }
   
     if (request->hasParam("numDirection",true)) {
      directionR= request->getParam("numDirection",true)->value();
    //numDirection=direction.toInt();
    direction=directionR.toInt();
    //direction = directionR;
      Serial.print(direction);
      Serial.print("\t");
 
    }
   if (request->hasParam("numFunction",true)) {
      fonctionR= request->getParam("numFunction",true)->value();
    //numDirection=direction.toInt();
    fonction = fonctionR.toInt();
    //direction = directionR;
      Serial.print(fonction);
     Serial.print("\t");
 
    }


  request->send(204);
    });


server.on("/readTurnout", HTTP_POST, [](AsyncWebServerRequest *request)
  {
    String turnoutR;
        if (request->hasParam("numTurnout",true)) {
      turnoutR= request->getParam("numTurnout",true)->value();
    //numDirection=direction.toInt();
    turnout = turnoutR.toInt();
    //direction = directionR;
      Serial.print(turnout);
      Serial.println();
  }
   request->send(204);
  });


     

  server.begin();
  Serial.println("Serveur actif!");


  
//------------------------------INTERRUPTION

  pinMode(PWM_PIN,OUTPUT);
  digitalWrite(PWM_PIN,HIGH);
  
  setup_ledc();
}



void setup_ledc() {
  ledcSetup(dcc_pin_channel,dcc_sig_freq,dcc_sig_resolution);
  ledcAttachPin(DCC_PIN,dcc_pin_channel);
  ledcWrite(dcc_pin_channel,dcc_sig_duty);
  attachInterrupt(DCC_PIN,dcc_sig_isr,RISING);
  
}

//structure du message
struct __attribute__((packed)) t_message { // total de 48 bits sur les 64

  uint64_t stop1: 1;       // 1 bit à 1
  uint8_t cksum: 8;      // 8 bits de verification
   uint8_t start3: 1;      // 1 bit à 0
   uint8_t SpeedDir: 8;   // 8 bits de direction et de vitesse
   uint8_t start2: 1;      // 1 bit à 0
   uint8_t address: 8;    // 8 bits d'adresse
    uint8_t start1: 1;      // 1 bit à 0
     uint8_t debut3: 4;      // 4 bits à 1
      uint8_t debut2: 8;      // 8 bits à 1
       uint8_t debut1: 8;     // 8 bits à 1
    

};

// on recompose une variable de 48 bits
void dumpMessageBits(t_message& message) {
   memcpy(&v, &message, sizeof v);
 
}

// la fonction construit le message et l'envoie avec la fonction dumpmassage
void buildMessage(t_message& message, byte loco, byte speed) {
message.debut1 = 0b11111111;
 message.debut2 =0b11111111;
  message.debut3 =0b1111;
  message.start1 = 0b0;
  message.address = loco;// message.address = addr;
  message.start2= 0b0;
  message.SpeedDir = speed; //Speedy;
  message.start3 = 0b0;
  message.cksum = loco^speed; //addr ^ Speedy; 
  message.stop1 = 0b1;

for (int i = 0; i<8;i++) {
  Serial.print(bitRead((message.debut1),i));
}
for (int i = 0; i<8;i++) {
  Serial.print(bitRead((message.debut2),i));
}
for (int i = 0; i<4;i++) {
  Serial.print(bitRead((message.debut3),i));
}
Serial.print("\t");

for (int i = 0; i<1;i++) {
  Serial.print(bitRead((message.start1),i));
}
Serial.print("\t");

for (int i = 0; i<8;i++) {
  Serial.print(bitRead((message.address),i));
}
Serial.print("\t");

for (int i = 0; i<1;i++) {
  Serial.print(bitRead((message.start2),i));
}
Serial.print("\t");

for (int i = 0; i<8;i++) {
  Serial.print(bitRead((message.SpeedDir),i));
}
Serial.print("\t");

for (int i = 0; i<1;i++) {
  Serial.print(bitRead((message.start3),i));
}
Serial.print("\t");

for (int i = 0; i<8;i++) {
  Serial.print(bitRead((message.cksum),i));
}
Serial.print("\t");

for (int i = 0; i<1;i++) {
  Serial.print(bitRead((message.stop1),i));
}
Serial.print("\t");

  Serial.println();
 dumpMessageBits(message);
}

t_message unMessage;

void IRAM_ATTR dcc_sig_isr() {
 // Serial.print(pointer);
//static uint32_t old_dcc_sig_freq ; // fréquence précédente
//Serial.print(pointer);
DccBit=!!(v&DccBitShift); // la variable v fait 48 bits il faut égrener
//DccBitShift>>=1; //on dácale les bits sur la droite


 if (DccBitShift) {
              if (DccBit) {
                    dcc_sig_freq=DCC_BIT_1_FREQ; // si tu pointes 1 envoie 1
           //  Serial.print(DccBit);

           }else{

                   dcc_sig_freq=DCC_BIT_0_FREQ;  // si tu pointes 0 envoie 0
       //Serial.print(DccBit);
            }
             
  if (dcc_sig_freq !=old_dcc_sig_freq) {
    ledc_set_freq(LEDC_HIGH_SPEED_MODE, LEDC_TIMER_0,dcc_sig_freq);
   dcc_sig_freq=old_dcc_sig_freq;
  }
 DccBitShift>>=1;
}else{
 // pointer; // quand le pointeur vaut 0 on recommence
 DccBitShift=0b100000000000000000000000000000000000000000000000;
 // Serial.println();
  pointer=48;
}

pointer--;
// le pointeur perd un  //on dácale les bits sur la droite

}




  void SpeedAndDir(uint8_t addrLoco, byte Cran, byte SpeedorPort, bool DirectorActivate, bool OpenorClose) // vecteur de direction et de vitesse 
{

  byte ext;
  byte extAcc;
  
  
//selectcran =6 =emerency
//selectcran 7 = smooth

uint8_t addrAcc;


      switch(Cran) {

          case 0:   ////DCC_PACKET_TYPE_STEP_14
              dccSpeed=map(SpeedorPort,0,14,0,14);
              if (dccSpeed) dccSpeed++; // pas de cran 1
              vecSpeed=(DirectorActivate?0x60:0x40)|dccSpeed; // vecteur vitesse  pour le cran 14
              vecLoco=addrLoco; // vecteur loco
              break;

              
          case 1: ///DCC_PACKET_TYPE_STEP_28

              dccSpeed=map(SpeedorPort,0,128,0,28);
              if (dccSpeed) dccSpeed+=3; // pas de cran 1,2,3
              ext=(((dccSpeed&0x01)<<5)|dccSpeed)>>1;   /// 
              vecSpeed=(DirectorActivate?0x60:0x40)|ext;
              vecLoco=addrLoco;
              break;
              
          case 2:  //DCC_PACKET_TYPE_STEP_128;
               dccSpeed=map(SpeedorPort,0,128,0,126);
              if (dccSpeed) dccSpeed++; // pas de cran 1
              vecSpeed=(DirectorActivate?0x60:0x40)|dccSpeed;
              vecLoco=addrLoco;
              break;

                case 4:  //ARRET CENRALS
               digitalWrite(PWM_PIN,LOW);
               vecLoco=addrLoco;
              break;  

                 case 5:  //CENTRAL MARCHE
               digitalWrite(PWM_PIN,HIGH);
              break;  

           case 6:  //IDLE;
               vecSpeed=0b00000000;
              break;       

          case 7:
              vecSpeed=0b01000000;
              vecLoco=addrLoco;
              break;

          case 8:
          vecSpeed=0b01000001;
           vecLoco=addrLoco;
          break;  

           case 9://ARRET FONCTION
          vecSpeed=0b10000000;
          vecLoco=addrLoco;
          break;    


          case 10: // fonction FL
          vecSpeed=0b10010000;
          vecLoco=addrLoco;
          break;
          
          case 11: // fonction F4
          vecSpeed=0b10001000;
          vecLoco=addrLoco;
          break;

           case 12: // fonction F3
          vecSpeed=0b10000100;
          vecLoco=addrLoco;
          break;

          case 13: // fonction F2
          vecSpeed=0b10000010;
          vecLoco=addrLoco;
          break;

          case 14: // fonction F1
          vecSpeed=0b10000001;
          vecLoco=addrLoco;
          break;

   
        case 100:
        addrAcc=(0b10<<6)|(addrLoco&0b00111111); // adresse de l accessoire on prend les 6 poids faibles et on rajoute 01
       extAcc = ((~((0b0000000111000000&addrLoco)>>6))|(1<<3))<<4;
        // on isole les 3 poids forts qu on complemente. on decale tout a gauche de 1bit pour faire 1 R8 R7 R6
        if (SpeedorPort==1) { // PORT = 0 0 = 1
          extAcc=extAcc& ~(1<<2);
          extAcc&=~(1<<1);
        } else if (SpeedorPort==2) { // PORT 0 1 = 2
         extAcc=extAcc& ~(1<<2);
          extAcc|= (1<<1);
        } else if (SpeedorPort==3) {// PORT 1 0 = 3
         extAcc=extAcc|(1<<2);
         extAcc&=~(1<<1);
        } else if (SpeedorPort==4) {  // PORT 1 1 = 4
        extAcc=extAcc|(1<<2);
        extAcc|= (1<<1);
        }
        vecLoco=addrAcc;
        extAcc=(DirectorActivate)?extAcc|=(1<<3):extAcc&=~(1<<3);
        extAcc=(OpenorClose)?extAcc|=(1<<0):extAcc&=~(1<<0);
        vecSpeed=extAcc;
        break;
        


      }
      

}



void loop(){

 SpeedAndDir(loco,1,speed,1,direction);
 //
delay(100);
  
buildMessage(unMessage,loco, speed);
}

lesept · June 18, 2023, 8:27pm

el_gringo:

static byte speed; //Speedy;
static byte vecSpeed;//
static byte dccSpeed;
static byte loco;//addr;
static byte vecLoco;
static bool direction;
static byte action;
static int fonction;
static int turnout;

Pourquoi toutes ces variables en static ?

el_gringo · June 18, 2023, 8:49pm

Ben dis donc bravo. Aucune raison. Et c'est ce qui faisait merdouiller cette partie.
merci.

system · December 15, 2023, 8:50pm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
ESPAsyncWebServer envoyer une réponse Français	3	138	January 11, 2025
ESP32 Serveur web Asynchrone Français	7	2266	May 6, 2021
Récupérer des valeurs depuis une page web sur un ESP32 Français	5	2793	June 26, 2021
Pas de page HTML qui s'affiche Français	10	86	May 12, 2025
Asynch Web Server automatisches öffnen von IP bei Verbindung mit softAP Deutsch	5	987	August 16, 2022

Question sur <ESPAsyncWebServer.h>

Related topics