blynk = bouton poussoir on/off

Bonjour,
est-il possible avec blynk d'avoir un lien avec le bouton poussoir "physique" et le "virtuel" ?

Bonjour,
Qu’entendez-vous par bouton virtuel?

Un bouton sur l'application mobile.

Vous devriez donner plus d'informations concernant votre montage (codes, schémas, ...).
Je pense, sans savoir exactement ce que vous faites, que vous pouvez faire clignoter une led avec un bouton physique et une application mobile.

voici mon projet :
Je veux contrôler un pompe a eau et un éclairage, avec deux relais, je veux les contrôler (on/off) avec deux deux bouton poussoir, et les contrôlé a distance avec l'application BLYNK. Pour cella je vais utiliser un arduino nano 33 IOT.
Et j'ai trois sonde de température branché en onewire.

Sur l'application blynk on peux programmer un changement de couleur du bouton en fonction de sa position (on/off). Ce que je voudrais, c,est lorsque j'appuie le bouton poussoirs, raccorder a l'arduino, le bouton change de couleur sur application.

Pour mon code il es assez compliquer, car brancher deux bouton poussoirs et pouvoir les faire fonctionné a tout moment est pas simple.

Le code arrive dans un second poste.

// **************************************
//                   températures, BP, Relais
// **************************************
#define BLYNK_PRINT Serial

#include <OneWire.h>
#include <WiFiNINA.h>
#include <BlynkSimpleWiFiNINA.h>

//BLYNK authentification + WIFI//
char auth[]= "----------";
char ssid[] = "----------";
char pass[]=  "---------";

// ********************** les entrées sorties
# define BP_1            5 // bouton poussoir en d2
# define BP_2            6 // boutton poussoir en d3
# define RELAIS1         3 // relais en d7
# define RELAIS2         4 // relais en d6
# define BROCHE_ONEWIRE  2 // Broche du bus 1-Wire
# define LED_V1          7 // led verte relais1 ON
# define LED_V2         10 // led verte relais2 ON
# define LED_R1         8 // led rouge relais1 OFF
# define LED_R2         12 // led rouge relais1 OFF

// ********************** relais et boutons poussoirs
boolean etatRelais1           = true;  // temoin etat relais 1
boolean etatRelais2           = true;  // temoin etat relais 2
int etat_S1                   =  0;
int etat_S2                   =  0;
int etat_precedent_S1         =  0;    // pour autoriser affichage sur moniteur
int etat_precedent_S2         =  0;    // pour autoriser affichage sur moniteur
int Val_BP_S1                 =  0;
int Val_BP_S2                 =  0;
unsigned long t_s1            =  0;
unsigned long t_s2            =  0;
unsigned long t_0_s1          =  0;
unsigned long t_0_s2          =  0;
unsigned long bounce_delay_s1 = 30;
unsigned long bounce_delay_s2 = 30;

// ******************************temperature
unsigned long periode_lecture_temp = 0;
/* Code de retour de la fonction getTemperature() */
enum DS18B20_RCODES
{
  READ_OK,
  NO_SENSOR_FOUND,
  INVALID_ADDRESS,
  INVALID_SENSOR
};
/* Création de l'objet OneWire pour manipuler le bus 1-Wire */
OneWire ds(BROCHE_ONEWIRE);
byte getTemperature(float *temperature, byte reset_search)
{
  byte data[9], addr[8];
  // data[] : Données lues depuis le scratchpad
  // addr[] : Adresse du module 1-Wire détecté
  /* Reset le bus 1-Wire ci nécessaire (requis pour la lecture du premier capteur) */
  if (reset_search) {
    ds.reset_search();
  }
  /* Recherche le prochain capteur 1-Wire disponible */
  if (!ds.search(addr)) {
    // Pas de capteur
    return NO_SENSOR_FOUND;
  }
  /* Vérifie que l'adresse a été correctement reçue */
  if (OneWire::crc8(addr, 7) != addr[7]) {Serial.println("mauvaise adresse ");
    // Adresse invalide
    return INVALID_ADDRESS;
  }
  /* Vérifie qu'il s'agit bien d'un DS18B20 */
  if (addr[0] != 0x28) {
    // Mauvais type de capteur
    return INVALID_SENSOR;
  }
  /* Reset le bus 1-Wire et sélectionne le capteur */
  ds.reset();
  ds.select(addr);
  /* Lance une prise de mesure de température et attend la fin de la mesure */
  ds.write(0x44, 1);
  //delay(800);
  /* Reset le bus 1-Wire, sélectionne le capteur et envoie une demande de lecture du scratchpad */
  ds.reset();
  ds.select(addr);
  ds.write(0xBE);
  /* Lecture du scratchpad */
  for (byte i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
  /* Calcul de la température en degré Celsius */
  *temperature = (int16_t) ((data[1] << 8) | data[0]) * 0.0625;
  
  return READ_OK;
}



////

void setup()
{
  Blynk.begin(auth, ssid, pass),
  pinMode(BP_1, INPUT_PULLUP);
  pinMode(RELAIS1, OUTPUT);
  pinMode(BP_2, INPUT_PULLUP);
  pinMode(RELAIS2, OUTPUT);
  Serial.begin(1000000);
  periode_lecture_temp = millis();
}

void loop()
{
  SM_Blynk();
  SM_relaiA();
  SM_relaiB();
  if ((millis()-periode_lecture_temp)>1000)//lecture toutes les secondes
  {
  periode_lecture_temp=millis();
  SM_temperature ();
  }
}

void SM_relaiA () {
  etat_precedent_S1 = etat_S1;          //memorise etat_S1
  switch (etat_S1)
  {
    case 0 :                            //sans appui sur BP=> etat_S1++  ???
      etat_S1 = 1; //Serial.println("case 0 =>1");
      break;

    case 1 :                                //boucle suivante
      Val_BP_S1 = digitalRead(BP_1);       //on guette le 1er appui sur BP

      if ( Val_BP_S1 == LOW) {
        //Serial.println("case 1 =>2");
        etat_S1 = 2; //et si BP enfoncé, etat_S1++
      }
      break;

    case 2 :                                 //boucle suivante
      t_0_s1 = millis();                     //relevé de l'heure
      etat_S1 = 3;                           // et etat_S1++
      //Serial.println("case 2 =>3");
      break;

    case 3 :                                 //boucle suivante
      Val_BP_S1 = digitalRead(BP_1);        //lecture entree BP
      if (Val_BP_S1 == HIGH)
      {
        t_s1 = millis();                      //si BP relaché relevé de l'heure
        etat_S1 = 4; //Serial.println("case 3 =>4");
      }
      break;

    case 4 :                            //5eme appui sur BP
      if ((millis() - t_0_s1) > bounce_delay_s1)
      {
        etat_S1 = 5; //Serial.println("case 4 =>5 car anti-rebonds terminé");
      }
      break;

    case 5 :
      Serial.println("triggered!_____11111111111111111111111111111111111_!");
       //delay(2000);
      etatRelais1 = !etatRelais1; // inverse l'état du relais
      digitalWrite(RELAIS1, etatRelais1);
      if(etatRelais1==true)
      {
        digitalWrite(LED_V1, HIGH);digitalWrite(LED_R1, LOW);
       // Serial.println("led verte 1 ON");Serial.println("led rouge 1 OFF");
      }
      else
      {
        digitalWrite(LED_V1, LOW);digitalWrite(LED_R1, HIGH);
        //Serial.println("led verte 1 OFF");Serial.println("led rouge 1 ON");
      }
      etat_S1 = 0; //Serial.println("case 5 =>0");
      break;
  }
  if (etat_S1 != etat_precedent_S1)//affichage sur moniteur autorisé
  {
    Serial.print("state= ");
    Serial.println(etat_S1);
  }
}


void SM_relaiB () {
  etat_precedent_S2 = etat_S2;          //memorise etat_S2
  switch (etat_S2)
  {
    case 0 :                            //sans appui sur BP=> etat_S2++  ???
      etat_S2 = 1; Serial.println("case 0 =>1");
      break;

    case 1 :                                //boucle suivante
      Val_BP_S2 = digitalRead(BP_2);       //on guette le 1er appui sur BP

      if ( Val_BP_S2 == LOW) {
      // Serial.println("case 1 =>2");
        etat_S2 = 2; //et si BP enfoncé, etat_S2++
      }
      break;

    case 2 :                                 //boucle suivante
      t_0_s2 = millis();                     //relevé de l'heure
      etat_S2 = 3;                           // et etat_S2++
      // Serial.println("case 2 =>3");
      break;

    case 3 :                                 //boucle suivante
      Val_BP_S2 = digitalRead(BP_2);        //lecture entree BP
      if (Val_BP_S2 == HIGH)
      {
        t_s2 = millis();                      //si BP relaché relevé de l'heure
        etat_S2 = 4; //Serial.println("case 3 =>4");
      }
      break;

    case 4 :                            //5eme appui sur BP
      if ((millis() - t_0_s2) > bounce_delay_s2)
      {
        etat_S2 = 5; //Serial.println("case 4 => 5 car anti-rebonds terminé");
      }
      break;

    case 5 :
      Serial.println("triggered!_____222222222222222222222222222222222_!");
      //delay(2000);
      etatRelais2 = !etatRelais2; // inverse l'état du relais
      digitalWrite(RELAIS2, etatRelais2);
      if(etatRelais2==true)
      {
        digitalWrite(LED_V2, HIGH);digitalWrite(LED_R2, LOW);
        //Serial.println("led verte 2 ON");Serial.println("led rouge 2 OFF");
      }
      else
      {
        digitalWrite(LED_V2, LOW);digitalWrite(LED_R2, HIGH);
        //Serial.println("led verte 2 OFF");Serial.println("led rouge 2 ON");
      }
      etat_S2 = 0; //Serial.println("case 5 =>0");
      break;
  }
  if (etat_S2 != etat_precedent_S2)//affichage sur moniteur autorisé
  {
    Serial.print("state= ");
    Serial.println(etat_S2);
  }
}
void SM_Blynk (){
Blynk.run();
}

void SM_temperature ()
{
  float temperature[3];
  if (getTemperature(&temperature[0], true) != READ_OK)
  {
    Serial.println(F("Erreur de lecture du capteur 1"));
    return;
  }
  if (getTemperature(&temperature[1], false) != READ_OK)
  {
    Serial.println(F("Erreur de lecture du capteur 2"));
    return;
  }
  if (getTemperature(&temperature[2], false) != READ_OK)
  {
    Serial.println(F("Erreur de lecture du capteur 3"));
    return;
  }

  /* Affiche les températures */
  Serial.print(F("Temperatures : "));
  Serial.print(temperature[0], 2);
  Serial.print("°");
  Serial.print(F("C, "));
  Serial.print(temperature[1], 2);
  Serial.print("°"); // Caractère degré
  Serial.print(F("C, "));
  Serial.print(temperature[2], 2);
  Serial.print("°");
  Serial.println('C');
  
}

Je pense que la couleur du bouton reflète l'état de ce qu'il contrôle. Donc si tu connais cet état (on off) il te suffit de demander à blynk de colorer le bouton selon cet état. Je ne sais pas si c'est faisable...