[SOLUCIONADO] Se repite el mensaje de salida como loco

Hola:

Hice un código de prueba sobre encender y apagar un Led 13 con Arduino UNO r3, con un pulsador en entrada digital número 8. Este es su código.

int estadoBoton=0; // Guardará el estado del botón HIGH o LOW.
char caracter;
String comando;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT); // Entrada digital donde está el pulsador.
  Serial.begin(115200);
}

void loop()
{
    estadoBoton=digitalRead(8); // Leer entrada digital número 8.
    // Si el pulsador está pulsado, se enciende el Led 13 y 
    // envía comando HIGH por el puerto serie.
 if (estadoBoton == HIGH) 
    { 
      digitalWrite(13,HIGH);
      Serial.println("HIGH");
    } 
 // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
 else
    {
      digitalWrite(13,LOW);
      Serial.println("LOW");
    }
}

He intentado hacer la misma función pero sigue con el mismo problema de enviar mensajes a lo loco como si fuera un bucle.

int estadoBoton=0; // Guardará el estado del botón HIGH o LOW.
char caracter;
String comando;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT); // Entrada digital donde está el pulsador.
  Serial.begin(115200);
}

void loop()
{
    estadoBoton=digitalRead(8); // Leer entrada digital número 8.
    // Si el pulsador está pulsado, se enciende el Led 13 y 
    // envía comando HIGH por el puerto serie.
      
    switch (estadoBoton)
{
  case 0:
      digitalWrite(13,HIGH);
      Serial.println("HIGH");
      break;
      
  case 1:
      digitalWrite(13,LOW);
      Serial.println("LOW");     
      break;
      default:
      Serial.println("Error desconocido");
}
}

Para quitar el bucle, hice esto de otra manera pero no funciona nada de nada.

int estadoBoton=0; // Guardará el estado del botón HIGH o LOW.
char caracter;
String comando;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT); // Entrada digital donde está el pulsador.
  Serial.begin(115200);


      
    switch (estadoBoton)
{
  case 0:
      digitalWrite(13,HIGH);
      Serial.println("HIGH");
      break;
      
  case 1:
      digitalWrite(13,LOW);
      Serial.println("LOW");     
      break;
      default:
      Serial.println("Error desconocido");
}
}

void loop()
{
        estadoBoton=digitalRead(8); // Leer entrada digital número 8.
    // Si el pulsador está pulsado, se enciende el Led 13 y 
    // envía comando HIGH por el puerto serie.
}

A parte de encender un Led, no hay ningún problema, si al enviar mensaje de texto como HIGH o LOW de forma muy repetitiva hasta colapsar el otro programa que tengo al recibir mensajes. El otro programa en un ordenador de sobre mesa con Visual Studio 2015.

¿Hay alguna solución?

Un cordial saludo.

Así es como yo lo solucionaría:

int estadoBoton=0; // Guardará el estado del botón HIGH o LOW.
int anteriorBoton=0;
char caracter;
String comando;
int flagMensaje=0;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT); // Entrada digital donde está el pulsador.
  Serial.begin(115200);
}

void loop()
{
    estadoBoton=digitalRead(8); // Leer entrada digital número 8.
    // Si el pulsador está pulsado, se enciende el Led 13 y 
    // envía comando HIGH por el puerto serie.

    if(estadoBoton != anteriorBoton){ // comprueba si ha habido un cambio en el estado del botón
      flagMensaje = 0;                // resetea la bandera a 0
      anteriorBoton = estadoBoton;    // guarda el estado actual del botón
    }

 if (estadoBoton == HIGH && flagMensaje == 0) // comprueba que el botón esté pulsado y que no se haya enviado el mensaje
    { 
      digitalWrite(13,HIGH);
      Serial.println("HIGH");
      
      if(flagMensaje == 0)                // si se envío el mensaje aumenta la variable a 1 para no enviarlo la próxima vez
        flagMensaje++;
    } 
 // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
 else if(flagMensaje == 0) // si el botón no está presionado y aún no se envía el mensaje
    {
      digitalWrite(13,LOW);
      Serial.println("LOW");
      
      if(flagMensaje == 0) // si se envió el mensaje aumenta la variable en 1 para no enviarla la próxima vez
        flagMensaje++;
    }
}

Veamos si esto funciona. Te recomiendo vayas a Documentación y veas los dos primeros tutoriales que te enseñaran los primeros pasos de Arduino.
Te harán falta.

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
char caracter;
String comando;
void setup(){
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   // 
  Serial.begin(115200);
}
void loop() {
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.
    // Si el pulsador está pulsado, se enciende el Led 13 y 
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == HIGH && estadoBotonAnt == LOW) { 
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
    }
       // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
         if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
      digitalWrite(13,LOW);
      Serial.println("LOW");   // sin el agregado de este if tendrian cientos de LOW en el MOnitor Serie
    }
     estadoBotonAnt = estadoBoton;
}

Con el agregado de una simple variable que mira el estadoAnterior, tu evistas en gran medida los rebotes que pueden complicar tu programa (no siempre funciona) pero lo mejor es que solo ves un cambio posible, entonces el programa responde

Hola:

Ya había hecho el código otra vez con flags, no me funciona bien del todo porque tiene antirebotes.

int estadoBoton=0; // Guardará el estado del botón HIGH o LOW.
char caracter;
String comando;
int flag = 0;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT); // Entrada digital donde está el pulsador.
  Serial.begin(115200);
}

 void loop()
{
    estadoBoton=digitalRead(8); // Leer entrada digital número 8.
    switch (estadoBoton)
{
  case 0:
      if(flag == 1){
      flag= 0;
      digitalWrite(13,HIGH);
      Serial.println("HIGH");
      }
      break;

  case 1:
      if(flag == 0){
      flag= 1;
      digitalWrite(13,LOW);
      Serial.println("LOW");
    }
      break;
      default:
      Serial.println("Error desconocido");
}
}

Veo que hice un código muy extenso comparado con ustedes. Voy a analizarlo.

Gracias por la ayuda.

Edito:
surbyte, he probado tu código.
Me pasa exactamente lo mismo que a mi del tema antirrebotes.

gepd , lo mismo pero menos errores de ese tipo.

¿Hay que poner un delay de 100 ms en algún lado?

Saludos.

Utilizando el código de surbyte que está más limpio que el mio, he agregado una verificación anti-rebote y creo que mejora un poco

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
long lastDebounceTime = 0;
char caracter;
String comando;

void setup(){
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   // 
  Serial.begin(115200);
}
void loop() {
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.
    // Si el pulsador está pulsado, se enciende el Led 13 y 
    // envía comando HIGH por el puerto serie.
  if ((millis() - lastDebounceTime) > 100)
  {
    if (estadoBoton == HIGH && estadoBotonAnt == LOW) { 
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
    }
       // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
         if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
      digitalWrite(13,LOW);
      Serial.println("LOW");   // sin el agregado de este if tendrian cientos de LOW en el MOnitor Serie
    }
    estadoBotonAnt = estadoBoton;
  } 
}

Hola:

Ya me funciona al 100 % sin cosas raras. Solo hay que poner un delay(100); al final de la instrucción.

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
char caracter;
String comando;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   //
  Serial.begin(115200);
}

void loop() {
    
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.
    
    // Si el pulsador está pulsado, se enciende el Led 13 y
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == HIGH && estadoBotonAnt == LOW)
    {
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        delay(100);
    }
    
    // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
        digitalWrite(13,LOW);
        Serial.println("LOW");   // sin el agregado de este if tendrian cientos de LOW en el Monitor Serie.
        delay(100);
    }
     estadoBotonAnt = estadoBoton;
}

Como dato curioso. Quiero enviarle al puerto serie con un comando desde Minotor Serie de Arduino IDE 1.6.6, ACTUALIZAR. Desde que escriba la palabra ACTUALIZAR, me dice el estado actual en el que se encuentra en interruptor, en HIGH o en LOW.

Quiero hacerlo ya que al tener el interruptor en un estado o en otro, es decir, en HIGH o en LOW, ejecuto Arduino, no sabe en qué estado se encuentra. Eso es hacerlo de forma manual, ya que manualmente debo enviar el comando ACTUALIZAR para que compruebe y notifique en que estado se encuentra.

El modo automático es cuando enciende Arduino o pulse Reset, automáticamente, gracias al código, envia el comando ACTUALIZAR para que se actualice los estados en que se encuentra.

Todo eso ya no se hacerlo.

Gracias a todo.

No es aconsejable el uso de delay. Cuando tu código aumente en complejidad, es una fuente de problemas.

Hay otra manera de evitar rebotes. Los ejemplos anteriores, que te propusieron, dejan de leer el pulsador por un tiempo después de ser accionado. Otra manera es esperar un ancho de pulso para ejecutar la acción

boolean estadoBoton = false; // Guardará el estado del botón HIGH o LOW.
boolean estadoBotonAnt = false;



void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   //
  Serial.begin(115200);
}

boolean leerboton(int n){
 
  long static tiempo_pulsado;
   long tiempo_actual;
   boolean   estado_actual_pulsador;

   tiempo_actual=millis();
  estado_actual_pulsador=  digitalRead(n);
  if (estado_actual_pulsador==false){
    tiempo_pulsado= tiempo_actual;
    
    return false;
    }else {
    if (abs(tiempo_actual-tiempo_pulsado)>1000)  {
      return true;
        }else {
    return false;}
     }
     
     
 }


void loop() {
   
    estadoBoton= leerboton(8); // Leer entrada digital número 8.
   
    // Si el pulsador está pulsado, se enciende el Led 13 y
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == true && estadoBotonAnt == false)
   {
      digitalWrite(13,HIGH);
      Serial.println("HIGH");
       
  }
   
    // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
   if (estadoBoton == false && estadoBotonAnt == true) {
      digitalWrite(13,LOW);
       Serial.println("LOW");   // sin el agregado de este if tendrian cientos de LOW en el Monitor Serie.
       
   }
   estadoBotonAnt = estadoBoton;
   //  Serial.println(estadoBoton);
}

La ventaja de esto, es que no detiene el codigo y proporciona seguridad. De hecho esa suele ser la manera de poner en marcha maquinas industriales. Se evita la puesta en marcha de la maquina accidentalmente por un pico de tensión o un "rozado" accidental del pulsador.

Cambiando el valor en "if (abs(tiempo_actual-tiempo_pulsado)>1000) " se obtiene diferentes tiempos de espera.

Tu ultima consulta sobre "actualizar" no la entendi.

Saludos

Lo siento geepd no había leído que ya habías posteado un codigo similar.

Saludos.

Todo bien Peter, he realizado una variación de las versiones anteriores, pero en vez de comprobar hace cuanto tiempo se presionó el botón, comprueba hace cuanto se realizó la secuencia encender y apagar, por lo que se puede definir en cuanto tiempo más quieres que se pueda volver a encender desde la última vez que estuvo apagada, quizás sea difícil de entender

pero aquí está el código

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
unsigned long lastStateTime = 0;
char caracter;
String comando;
int first = 1;

void setup(){
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   // 
  Serial.begin(115200);
}
void loop() {
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.

    if (estadoBoton == HIGH && estadoBotonAnt == LOW && first == 1) { 
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        first = 2;
    }
       // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH && first == 2) {
      digitalWrite(13,LOW);
      Serial.println("LOW");   // sin el agregado de este if tendrian cientos de LOW en el MOnitor Serie
      first = 0;
    }
    estadoBotonAnt = estadoBoton;
    
    if(estadoBoton == LOW && millis() - lastStateTime > 1000){
      lastStateTime = millis();
      first = 1;
    } 
}

Si cambias el valor para definir cada cuanto tiempo quieres permitir nuevamente la secuencia puedes obtener un resultado como el que quieres

if(estadoBoton == LOW && millis() - lastStateTime > 1000){ // 1000 es el tiempo a cambiar

Como ejemplo para entender mejor, es que si cambiar el valor a 30 segundos, el código te permitirá encender y apagar el led sin problemas la primera vez, pero cuando lo intentes nuevamente tendrás que esperar los 30 segundos que definiste. Al bajar este valor a 1 segundo o 1.5 segundos, tienes un botón con un resultado muy aceptable.

Hola:

Lo de ACTUALIZAR, para explicarlo mejor a lo que me refiero.

Tengo el interruptor en HIGH o LOW, de una manera o otra, vamos a dejarlo en LOW. Apago Arduino, lo vuelvo a encender. Desde el PC, usando un programa en PC que he creado, no sabe que estado está ese interruptor, si luego le doy al interruptor al pasarlo a HIGH, en el PC ahora si sabe que estado está, ya que lo acabo de modificar, pero no sabe nada al encender Arduino. El programa puede ser el Hyper Terminal de Windows e incluso el Monito Serie para comprabar estado.

Por eso hay que hacer una parete del programa en Arduino, que al encenderlo, envíe los estados del interruptor por el puerto serie o USB al Monitor Serie para saber su estado.

¿Se entiende?

Lo puedo explicar de otra manera con capturas.

Gracias por los códigos.

Saludos.

Creo que no es la solución más elegante pero hace lo que pides:

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
unsigned long lastStateTime = 0;
char caracter;
String comando;
int first = 1;
int boot = 0;

void setup(){
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   // 
  Serial.begin(115200);
}
void loop() {
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.

    // imprime el estado al encender arduino
    if(boot == 0 && estadoBoton == 0){
      Serial.println("LOW");
      boot++;
    }else if(boot == 0 && estadoBoton == 1){
      Serial.println("HIGH");
      boot++;
    }

    if (estadoBoton == HIGH && estadoBotonAnt == LOW && first == 1) { 
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        first = 2;
    }
       // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH && first == 2) {
      digitalWrite(13,LOW);
      Serial.println("LOW");   // sin el agregado de este if tendrian cientos de LOW en el MOnitor Serie
      first = 0;
    }
    estadoBotonAnt = estadoBoton;
    
    if(estadoBoton == LOW && millis() - lastStateTime > 1000){
      lastStateTime = millis();
      first = 1;
    } 
}

Hola:

He probado el pedazo de código tiene comportamientos no deseado. Las pruebas que he hecho son estas:

Dejo el interruptor en modo LOW, reseteo Arduino y me aparece este mensaje en el Monitor Serie.

LOW

Dejo el interruptor en modo HIGH, reseteo Arduino y me aparece este mensaje.
HIGH
HIGH

Al pulsar varias veces el interruptor cuando Arduino ya está encendido, a veces no da respuesta en el interruptor, no muestra mensaje en el Monitor Serie, para saber si es el dicho Monitor Serie, he probado con Visual Studio mi propio programa e incluso con Hyper Terminal de Windows para verificar, es decir, compruebo que tiene comportamientos no deseados.

Modificando el código más sencillo con el dalay(100); que no gusta porque el AVR se queda esclavo en ese tiempo y no hace nada más hasta que acabe esa rutina, ocurre el mimso comportamiento.

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
char caracter;
String comando;
int boot = 0;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   //
  Serial.begin(115200);
}

void loop() {
    
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.

        // imprime el estado al encender arduino
    if(boot == 0 && estadoBoton == 0){
      Serial.println("LOW");
      boot++;
    }else if(boot == 0 && estadoBoton == 1){
      Serial.println("HIGH");
      boot++;
    }
    
    // Si el pulsador está pulsado, se enciende el Led 13 y
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == HIGH && estadoBotonAnt == LOW)
    {
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        delay(100);
    }
    
    // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
        digitalWrite(13,LOW);
        Serial.println("LOW");
        delay(100);
    }
     estadoBotonAnt = estadoBoton;
}

Deduzco que el problema tiene que ser de este código que no está programado de forma correcta del todo.

        // imprime el estado al encender arduino
    if(boot == 0 && estadoBoton == 0){
      Serial.println("LOW");
      boot++;
    }else if(boot == 0 && estadoBoton == 1){
      Serial.println("HIGH");
      boot++;
    }

Un cordial saludo.

Hice algunas modificaciones para evitar el doble mensaje de HIGH, cuando no te muestra el mensaje por la consola es justamente por el anti-rebote, deduzco que cuando dices "al pulsar varias veces" además es rápido, para evitar eso en el código que te dejé debes bajar el tiempo de intervalo a menos de 1 segundo, yo lo he bajado a 200 milisegundos, pero recuerda, mientras más bajo es ese valor más rebotará el botón.

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
unsigned long lastStateTime = 0;
char caracter;
String comando;
int first = 1;

void setup(){
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   // 
  Serial.begin(115200);

  estadoBoton = digitalRead(8);

  if(estadoBoton == 0){
      Serial.println("LOW");
    }else{
      Serial.println("HIGH");
      first = 2;
    }

    estadoBotonAnt = estadoBoton;
    lastStateTime = millis();
}
void loop() {
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.

    if (estadoBoton == HIGH && estadoBotonAnt == LOW && first == 1) { 
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        first = 2;
    }
       // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH && first == 2) {
      digitalWrite(13,LOW);
      Serial.println("LOW");   // sin el agregado de este if tendrian cientos de LOW en el MOnitor Serie
      first = 0;
    }
    estadoBotonAnt = estadoBoton;
    
    if(estadoBoton == LOW && millis() - lastStateTime > 200){
      lastStateTime = millis();
      first = 1;
    } 
}

¿Cuál es el uso que le vas a dar a este circuito? Quizás conocer un poco más sobre el proyecto pueda ayudar a resolverlo con otro enfoque.

Saludos

Hola:

El proyecto es simple, Monitorización entradas digitales.

Probando el código, tanto en 200 ms (0.2 sg) como en 1000 ms (1 sg) tiene efectos de antirebotes. Lo que se ha arreglado es al resetear o encender Arduino, ya no muestra dos HIGH y cosas raras. A veces por mucho que toque el interruptor, no aparece ningún valor.

Un cordial saludo.

Intenta entender un poco más el código. A pesar de que en mis pruebas el botón funcionaba relativamente bien, a veces no mostraba nada porque el valor de intervalo aún era muy alto, al bajarlo a 50 siempre marca el estado del botón

if(estadoBoton == LOW && millis() - lastStateTime > 50){

Has la prueba y me dices, si a ti no te funciona bien puede ser algún problema con tu botón.
Lo usas con una resistencia pull down verdad?

Hola:

Lo he probado y si pongo a LOW me sale esto siempre.

LOW
HIGH
LOW

Si, uso push-up e down para probar. También uso pulsadores haber que pasa.

El mejor código que rsponde bien sin problemas en los antirebotes es este que he probado hasta ahora.

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
char caracter;
String comando;
int boot = 0;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   //
  Serial.begin(115200);
}

void loop() {
    
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.
 
    // Si el pulsador está pulsado, se enciende el Led 13 y
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == HIGH && estadoBotonAnt == LOW)
    {
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        delay(50);
    }
    
    // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
        digitalWrite(13,LOW);
        Serial.println("LOW");
        delay(50);
    }
     estadoBotonAnt = estadoBoton;
}

Solo falla el sistema este código que pusiste sobre actualizar lso datos cuando se resetea o enciende Arduino.

        // imprime el estado al encender arduino
    if(boot == 0 && estadoBoton == 0){
      Serial.println("LOW");
      boot++;
    }else if(boot == 0 && estadoBoton == 1){
      Serial.println("HIGH");
      boot++;
    }

Sumado todo junto sería así:

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
char caracter;
String comando;
int boot = 0;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   //
  Serial.begin(115200);
}

void loop() {
    
    estadoBoton = digitalRead(8); // Leer entrada digital número 8.

        // imprime el estado al encender arduino
    if(boot == 0 && estadoBoton == 0){
      Serial.println("LOW");
      boot++;
    }else if(boot == 0 && estadoBoton == 1){
      Serial.println("HIGH");
      boot++;
    }
 
    // Si el pulsador está pulsado, se enciende el Led 13 y
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == HIGH && estadoBotonAnt == LOW)
    {
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        delay(50);
    }
    
    // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
        digitalWrite(13,LOW);
        Serial.println("LOW");
        delay(50);
    }
     estadoBotonAnt = estadoBoton;
}

El único solo problema que encuentro es que al resetear Arduino con el interruptor en HIGH, me salta con doble HIGH.

HIGH
HIGH

En el Monitor Serie.

En modo LOW si lo hace una vez, como debe ser.

Saludos.

coloca el código en el setup

void setup() {
     estadoBoton = digitalRead(8); // Leer entrada digital número 8.

        // imprime el estado al encender arduino
    if(boot == 0 && estadoBoton == 0){
      Serial.println("LOW");
      boot++;
    }else if(boot == 0 && estadoBoton == 1){
      Serial.println("HIGH");
      boot++;
    }
}

De todas maneras pienso que el problema no es el código porque no es posible que varíe tanto cuando tu lo pruebas a las pruebas que hago yo con el exactamente el mismo sketch.

Así es como yo tengo conectado el pulsador (La resistencia es de 10K):
FGFS_basics_pushbutton.jpg

Metaconta:
Hola:

El proyecto es simple, Monitorización entradas digitales.

Probando el código, tanto en 200 ms (0.2 sg) como en 1000 ms (1 sg) tiene efectos de antirebotes. Lo que se ha arreglado es al resetear o encender Arduino, ya no muestra dos HIGH y cosas raras. A veces por mucho que toque el interruptor, no aparece ningún valor.

Un cordial saludo.

Si vas a monitorear mas de una señal digital te convendría utilizar un protocolo de comunicación ya adaptado a eso, como modbus, y no intentar reinventar la rueda.

Saludos.

He probado el en Setuo este código que me aconsejastee.

byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
char caracter;
String comando;
int boot = 0;

void setup()
{
  pinMode(13,OUTPUT); // Donde está el Led 13.
  pinMode(8,INPUT);   //
  Serial.begin(115200);

          // imprime el estado al encender arduino
    if(boot == 0 && estadoBoton == 0){
      Serial.println("LOW");
      boot++;
    }else if(boot == 0 && estadoBoton == 1){
      Serial.println("HIGH");
      boot++;
    }
}

void loop() {
 
    // Si el pulsador está pulsado, se enciende el Led 13 y
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == HIGH && estadoBotonAnt == LOW)
    {
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        delay(50);
    }
    
    // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
        digitalWrite(13,LOW);
        Serial.println("LOW");
        delay(50);
    }
     estadoBotonAnt = estadoBoton;
}

Solo funciona en LOW cuando lo enciendes o pulsar Reset, no conmuta en nada más por mucho que pulse el interruptor. Tengo bien hecho el interruptor, gracias por el esquema.

Voy a investigar el modbus, eso si, aún quiero saber lo básico de las netradas digitales.

Saludos.

Eso es porque borraste la lectura del estado del botón

estadoBoton = digitalRead(8); // Leer entrada digital número 8.
byte estadoBoton = 0; // Guardará el estado del botón HIGH o LOW.
byte estadoBotonAnt = 0;
char caracter;
String comando;

void setup()
{
	pinMode(13,OUTPUT); // Donde está el Led 13.
	pinMode(8,INPUT);   //
	Serial.begin(115200);

	estadoBoton = digitalRead(8);

	// imprime el estado al encender arduino
	if(estadoBoton == 0){
		Serial.println("LOW");
	}else{
		Serial.println("HIGH");
	}
}

void loop() {

	estadoBoton = digitalRead(8);
 
    // Si el pulsador está pulsado, se enciende el Led 13 y
    // envía comando HIGH por el puerto serie.
    if (estadoBoton == HIGH && estadoBotonAnt == LOW)
    {
        digitalWrite(13,HIGH);
        Serial.println("HIGH");
        delay(50);
    }
    
    // De lo contrario, Led 13 epagado y envía LOW al puerto serie.
    if (estadoBoton == LOW && estadoBotonAnt == HIGH) {
        digitalWrite(13,LOW);
        Serial.println("LOW");
        delay(50);
    }
     estadoBotonAnt = estadoBoton;
}

De verdad estaría bueno que fueses a la sección de documentación y vieras los tutoriales que hay de arduino, el error anterior es muy básico, te ayudará para comprender los códigos, no hagas lo de copiar y pegar, si bien te funcionará el sketch pero no aprenderás nada.