Problemas con iniciación de codigo y blynk

[xaviscam]

Buenas tardes, Tengo un problema con el código de Arduino y blynk. En mi código debo flashear una distancia en la memoria del nano para tenerla como referencia, y para ello le configure en uno de los interruptores (InterruptorA) una secuencia de 3 pulsaciones, dejando la tercera presionada hasta que sonase el zumbador 3 veces. De esta manera, configuración de distancia inicial quedaba grabada. El problema es que si desconecto el Arduino del PC no me reconoce las tres pulsaciones (que no entiendo) y la otra es que creo que si no está conectado a internet no funciona, cuando la idea es que funcione tanto si lo está como si no. La conexión a internet la tengo para leer los valores que me da el sensor y los interruptores desde blynk e incluso cambiar algún parámetro que no me acabe de hacer.

El código sin blynk funciona genial pero con él no.

Mi arduino es un NANO 33 IOT

Espero haber seguido las normas del foro correctamente y agradezco cualquier ayuda que me podáis ofrecer.

#define BLYNK_TEMPLATE_ID "xxxxxxxx"
#define BLYNK_TEMPLATE_NAME "xxxxxxx"
#define BLYNK_AUTH_TOKEN "xxxxxxxx"

#include <Wire.h>
#include <Arduino_LSM6DS3.h>
#include "Adafruit_VL6180X.h"
#include <BlynkSimpleWiFiNINA.h>
#include <FlashStorage.h>

Adafruit_VL6180X vl = Adafruit_VL6180X();

const int pinInterruptorA = 11;
const int pinSalidaA = 2;
const int pinInterruptorB = 12;
const int pinSalidaB = 3;
const int pinZumbador = 4;

bool estadoInterruptorA = false;
bool estadoInterruptorB = false;
bool zumbadorActivadoA = false;
bool zumbadorActivadoB = false;

float distanciaConfiguracionInicial = 0.00;
float distanciaFijada = 0.00;
float distanciaA = 0.00;
float rangoMinimo = 0;
float rangoMaximo = 0;
float distanciaInicial = 0.00;
float x = 0.00;
float y = 0.00;
float z = 0.00;
float tiempo_transcurrido = 0.10;
float velocidad = 0.00;
float incrementoVus = 0.00;
float velocidadUmbralInferior = 0.00;
float velocidadUmbralSuperior = 0.00;
float incrementoMin = 0;
float incrementoMax = 0;

struct Configuracion {
  float distanciaConfiguracionInicial;
};

FlashStorage(configuracion, Configuracion);

BLYNK_WRITE(V16) {
  incrementoMin = param.asFloat();
}

BLYNK_WRITE(V17) {
  incrementoMax = param.asFloat();
}

BLYNK_WRITE(V8) {
  incrementoVus = param.asFloat();
}

char auth[] = "xxxxxx";
char ssid[] = "xxxxxx";
char pass[] = "xxxxxxx";

BlynkTimer timer;

void enviarDatosBlynk();
void controlarInterruptores();

unsigned long tiempoUltimaPulsacion = 0;
const unsigned long intervaloMinimo = 500;  // Intervalo mínimo entre pulsaciones en milisegundos

void configuracionInicial() {
  int contadorPulsaciones = 0;

  // Espera tres pulsaciones consecutivas
  while (contadorPulsaciones < 3) {
    bool estadoInterruptorA = digitalRead(pinInterruptorA) == HIGH;

    // Verifica si el interruptor está en estado HIGH y ha pasado el intervalo mínimo
    if (estadoInterruptorA && (millis() - tiempoUltimaPulsacion) > intervaloMinimo) {
      contadorPulsaciones++;
      tiempoUltimaPulsacion = millis();
      delay(500);  // Pausa después de cada pulsación, ajusta según tus necesidades
    }
  }

  delay(2000);  // Espera un intervalo prolongado después de las tres pulsaciones, ajusta según tus necesidades

  for (int i = 0; i < 3; i++) {
    digitalWrite(pinZumbador, HIGH);
    delay(500);
    digitalWrite(pinZumbador, LOW);
    delay(500);
  }

  distanciaInicial = vl.readRange();  // Lee la distancia inicial después de las tres pulsaciones

  Serial.print("DGI: ");
  Serial.print(distanciaInicial);
  Serial.println(" mm");
  
  distanciaConfiguracionInicial = distanciaInicial;

  Configuracion conf;
  conf.distanciaConfiguracionInicial = distanciaConfiguracionInicial;
  configuracion.write(conf);
}

void setup() {
  Serial.begin(115200);
  if (!IMU.begin()) {
    Serial.println("Failed to initialize IMU!");
    while (1);
  }

  Serial.println("IMU initialized!");

  while (!Serial) {
    delay(1);
  }

  Serial.println("Adafruit VL6180x test!");
  if (!vl.begin()) {
    Serial.println("Failed to find sensor");
    while (1);
  }
  Serial.println("Sensor found!");

  pinMode(pinSalidaA, OUTPUT);
  pinMode(pinSalidaB, OUTPUT);
  pinMode(pinZumbador, OUTPUT);
  pinMode(pinInterruptorA, INPUT_PULLUP);
  pinMode(pinInterruptorB, INPUT_PULLUP);

  //Blynk.config(auth, ssid, pass);
  // Esperar hasta que se establezca la conexión a Blynk antes de continuar
 // while (Blynk.connect()) {
    // Puedes agregar algún indicador o manejo aquí
    //delay(1000);
 // }

  configuracionInicial();

  Blynk.virtualWrite(V20, pinInterruptorA);
  Blynk.virtualWrite(V21, pinInterruptorB);
  Blynk.virtualWrite(V3, pinSalidaA);
  Blynk.virtualWrite(V4, pinSalidaB);

  timer.setInterval(1000L, enviarDatosBlynk);
}

void loop() {
 // Blynk.run();
 // timer.run();
  controlarInterruptores();
  enviarDatosBlynk();
}

void enviarDatosBlynk() {
  //if (Blynk.connected()){
  float aceleracion, x, y, z, velocidad, umbralSuperior, tiempo;
  float datosBlynk1 = distanciaInicial;
  float datosBlynk2 = distanciaA;
  float datosBlynk3 = rangoMinimo;
  float datosBlynk4 = rangoMaximo;
  float datosBlynk5 = distanciaFijada;
  float datosBlynk6 = aceleracion + x + y + z + velocidad + umbralSuperior + tiempo;
  float datosBlynk7 = aceleracion;
  float datosBlynk8 = x;
  float datosBlynk9 = y;
  float datosBlynk10 = z;
  float datosBlynk11 = velocidad;
  float datosBlynk12 = velocidadUmbralSuperior;
  float datosBlynk13 = tiempo_transcurrido;

  Blynk.virtualWrite(V1, distanciaInicial);
  Blynk.virtualWrite(V2, distanciaA);
  Blynk.virtualWrite(V3, estadoInterruptorA ? HIGH : LOW);
  Blynk.virtualWrite(V4, estadoInterruptorB ? HIGH : LOW);
  Blynk.virtualWrite(V5, rangoMinimo);
  Blynk.virtualWrite(V6, rangoMaximo);
  Blynk.virtualWrite(V7, distanciaFijada);
}
//}
void controlarInterruptores() {
  float x, y, z;
  distanciaA = vl.readRange();
  rangoMinimo = distanciaConfiguracionInicial + incrementoMin;
  rangoMaximo = (distanciaConfiguracionInicial + incrementoMax) * 2;
  velocidadUmbralSuperior = 0.05 + incrementoVus;

  if (distanciaConfiguracionInicial == 0) {
   // distanciaConfiguracionInicial = configuracionInicial();
  }

  estadoInterruptorA = (digitalRead(pinInterruptorA) == HIGH);
  estadoInterruptorB = (digitalRead(pinInterruptorB) == HIGH);

  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    Serial.print("Aceleración (x, y, z): ");
    Serial.print(x);
    Serial.print(", ");
    Serial.print(y);
    Serial.print(", ");
    Serial.println(z);
    velocidad = sqrt(x * x + y * y + z * z) * tiempo_transcurrido;
    Blynk.virtualWrite(V9, x);
    Blynk.virtualWrite(V10, y);
    Blynk.virtualWrite(V11, z);
    Blynk.virtualWrite(V12, velocidad);
    Blynk.virtualWrite(V14, velocidadUmbralSuperior);
    Blynk.virtualWrite(V15, tiempo_transcurrido);
    // Serial.println(velocidad);
  } else {
    velocidadUmbralInferior = 0.00;  // Ajusta este valor según tus necesidades
    tiempo_transcurrido = 0.10;  // Ajusta el tiempo según tus necesidades
  }
  Serial.print("Velocidad: ");
  Serial.println(velocidad);

  if (velocidad >= velocidadUmbralInferior && velocidad <= velocidadUmbralSuperior) {
    digitalWrite(pinSalidaA, estadoInterruptorA ? HIGH : LOW);
  } else {
    if (estadoInterruptorA) {
      distanciaA = vl.readRange();
      Serial.print("Distancia A: ");
      Serial.print(distanciaA);
      Serial.println(" mm");

      // Imprimir la distancia grabada en configuración inicial
      Serial.print("DGI: ");
      Serial.print(distanciaInicial);
      Serial.println(" mm");
      if (distanciaA >= distanciaConfiguracionInicial + 5 && distanciaA <= (distanciaConfiguracionInicial + 10) * 2) {
        digitalWrite(pinSalidaA, HIGH);

        if (!zumbadorActivadoA) {
          digitalWrite(pinZumbador, HIGH);
          delay(1000);
          digitalWrite(pinZumbador, LOW);
          zumbadorActivadoA = true;
        }

        if (distanciaFijada == 0) {
          distanciaFijada = distanciaA;
        }
      } else {
        digitalWrite(pinSalidaA, distanciaFijada > 0 ? HIGH : LOW);
        zumbadorActivadoA = false;
      }
    } else {
      digitalWrite(pinSalidaA, distanciaFijada > 0 ? HIGH : LOW);
      zumbadorActivadoA = false;
    }

    if (estadoInterruptorB) {
      if (!zumbadorActivadoB) {
        digitalWrite(pinZumbador, HIGH);
        delay(100);
        digitalWrite(pinZumbador, LOW);
        delay(100);
        digitalWrite(pinZumbador, HIGH);
        delay(100);
        digitalWrite(pinZumbador, LOW);
        zumbadorActivadoB = true;
      }
      delay(3000);

      digitalWrite(pinSalidaB, estadoInterruptorA ? HIGH : LOW);

      if (!zumbadorActivadoB && distanciaFijada == 0) {
        Serial.println("Zumbador B activado");
      }
    } else {
      if (!estadoInterruptorA) {
        zumbadorActivadoB = false;
      } else {
        digitalWrite(pinSalidaB, LOW);
        zumbadorActivadoB = false;
      }
    }

    // Imprime Rangos
    Serial.print("Rango mínimo: ");
    Serial.print(rangoMinimo);
    Serial.println(" mm");
    Serial.print("Rango máximo: ");
    Serial.print(rangoMaximo);
    Serial.println(" mm");

    if (estadoInterruptorA && estadoInterruptorB && distanciaFijada > 0) {
      Serial.print("Distancia fijada actual: ");
      Serial.print(distanciaFijada);
      Serial.println(" mm");
    }

    if (!estadoInterruptorA || !estadoInterruptorB) {
      distanciaFijada = 0;
    }
  }

  delay(100);
}

[DanX3]

@xaviscam

  while (!Serial) {
    delay(1);
  }

Presupongo que si no tienes conectado al serial ahí se queda en ese bucle.