executar açao apenas uma vez dentro do loop (SOU INICIANTE)

ola, sou iniciante e estou tentando fazer o programa acionar um rele apenas uma vez quando o sistema ler determinado valor

if ( result > 2.12 && result < 2.45 ) {

digitalWrite(rele1, HIGH);

digitalWrite(rele11, LOW);

}
else {

digitalWrite(rele1, LOW);

digitalWrite(rele11, HIGH);

}

estou usando 2 reles como ponte H e tenho 1 rele que livera a energia,
quando o arduino lesse o valor 2.12 e 2.45 ele giraria para um lado e quando
apresentasse valor fora disso girasse para o outro, tenho mais 2 açoes como essa mas com valores diferentes, e quando saisse de uma e fosse para a outra queria que o rele que libera energia ligasse por 1 segundo, se quiser o codigo completo coloco aqui depois

Coloca o código completo aí!

tecdiego:
Coloca o código completo aí!

#define acoplador 13

int i;

int sign;

long value;

float result;

int clockpin = 4;

int datapin = 5;


int tempo_de_acopl = 5000;


int rele1 = 12;

int rele11 = 11;

int rele2 = 10;

int rele22 = 9;

int rele3 = 8;

int rele33 = 7;




unsigned long tempmicros;


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {




  Serial.begin(9600);

  pinMode(clockpin, INPUT);

  pinMode(datapin, INPUT);

  pinMode(rele1, OUTPUT);

  pinMode(rele2, OUTPUT);

    pinMode(rele3, OUTPUT);

     pinMode(rele11, OUTPUT);

  pinMode(rele22, OUTPUT);

    pinMode(rele33, OUTPUT);

pinMode(acoplador,OUTPUT);    

}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop () {





  while (digitalRead(clockpin) == HIGH) {} //if clock is LOW wait until it turns to HIGH

  tempmicros = micros();

  while (digitalRead(clockpin) == LOW) {} //wait for the end of the HIGH pulse

  if ((micros() - tempmicros) > 500) { //if the HIGH pulse was longer than 500 micros we are at the start of a new bit sequence

    decode(); //decode the bit sequence

  }



}



void decode() {

  sign = 1;

  value = 0;

  for (i = 0; i < 23; i++) {

    while (digitalRead(clockpin) == HIGH) { } //wait until clock returns to HIGH- the first bit is not needed

    while (digitalRead(clockpin) == LOW) {} //wait until clock returns to LOW

    if (digitalRead(datapin) == LOW) {

      if (i < 20) {

        value |= 1 << i;

      }

      if (i == 20) {

        sign = -1;

      }

    }

  }



  ///////////////////////////////////////////////////////////////////////////////////////////////////////////

  result = (value * sign) / 3856.8376068376;

  Serial.println(result, 2); //print result with 2 decimals

  delay(5);

  if ( result > 2.12 && result < 2.45 ) {


    digitalWrite(rele1, HIGH);

    digitalWrite(rele11, LOW);


  }
  else {

    digitalWrite(rele1, LOW);

    digitalWrite(rele11, HIGH);

  
  }

  if ( result > 2.45 && result < 3.19 ) {


    digitalWrite(rele3, HIGH);

    digitalWrite(rele33, HIGH);

 

  }
  else {


    digitalWrite(rele3, LOW);

    digitalWrite(rele33, HIGH);


  }













 if ( result > 2.12 && result < 3.19 ) {


    digitalWrite(rele2, LOW);

     digitalWrite(rele22, HIGH);

  }
  else {


    digitalWrite(rele2, HIGH);

     digitalWrite(rele22, LOW);


 
  }















//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


if ( result > 2.12 && result < 2.45 ) {


  acopl (); 
  }



if ( result > 2.45 && result < 3.19 ) {

acopl (); 
 
}
  
 if ( result > 0.00 && result < 2.12) {

  acopl (); 

  
 }


 if ( result > 3.19 && result < 10.00) {

  acopl (); 

 }



}

void acopl() {

  


digitalWrite(acoplador, HIGH); 
 
delay(tempo_de_acopl); 

digitalWrite(acoplador, LOW);


 
}

talvez vc nao entenda muito a parte da leitura do resultado, mas ele e parte de um codigo do youtube (caliper digital ) ( https://www.youtube.com/watch?v=dborXvt7DA8)

a unica coisa q nao consigo e ligar por apenas 1 ou 2 segundos o rele que energiza os outros (se ficar ligado, como ele tem um fim ele tranca e queimara)

esse codigo que mandei foi a ultima tentativa que realizei sem sucesso de ligar

se quiser ainda adiciona alguns comentarios no codigo para melhor entender

desde ja agradeço a ajuda

Vitor_Brzozkowski:

#define acoplador 13

int i;

int sign;

long value;

float result;

int clockpin = 4;

int datapin = 5;

int tempo_de_acopl = 5000;

int rele1 = 12;

int rele11 = 11;

int rele2 = 10;

int rele22 = 9;

int rele3 = 8;

int rele33 = 7;

unsigned long tempmicros;

///////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {

Serial.begin(9600);

pinMode(clockpin, INPUT);

pinMode(datapin, INPUT);

pinMode(rele1, OUTPUT);

pinMode(rele2, OUTPUT);

pinMode(rele3, OUTPUT);

pinMode(rele11, OUTPUT);

pinMode(rele22, OUTPUT);

pinMode(rele33, OUTPUT);

pinMode(acoplador,OUTPUT);

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop () {

while (digitalRead(clockpin) == HIGH) {} //if clock is LOW wait until it turns to HIGH

tempmicros = micros();

while (digitalRead(clockpin) == LOW) {} //wait for the end of the HIGH pulse

if ((micros() - tempmicros) > 500) { //if the HIGH pulse was longer than 500 micros we are at the start of a new bit sequence

decode(); //decode the bit sequence

}

}

void decode() {

sign = 1;

value = 0;

for (i = 0; i < 23; i++) {

while (digitalRead(clockpin) == HIGH) { } //wait until clock returns to HIGH- the first bit is not needed

while (digitalRead(clockpin) == LOW) {} //wait until clock returns to LOW

if (digitalRead(datapin) == LOW) {

if (i < 20) {

value |= 1 << i;

}

if (i == 20) {

sign = -1;

}

}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

result = (value * sign) / 3856.8376068376;

Serial.println(result, 2); //print result with 2 decimals

delay(5);

if ( result > 2.12 && result < 2.45 ) {

digitalWrite(rele1, HIGH);

digitalWrite(rele11, LOW);

}
  else {

digitalWrite(rele1, LOW);

digitalWrite(rele11, HIGH);

}

if ( result > 2.45 && result < 3.19 ) {

digitalWrite(rele3, HIGH);

digitalWrite(rele33, HIGH);

}
  else {

digitalWrite(rele3, LOW);

digitalWrite(rele33, HIGH);

}

if ( result > 2.12 && result < 3.19 ) {

digitalWrite(rele2, LOW);

digitalWrite(rele22, HIGH);

}
  else {

digitalWrite(rele2, HIGH);

digitalWrite(rele22, LOW);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

if ( result > 2.12 && result < 2.45 ) {

acopl ();
  }

if ( result > 2.45 && result < 3.19 ) {

acopl ();

}
 
if ( result > 0.00 && result < 2.12) {

acopl ();

}

if ( result > 3.19 && result < 10.00) {

acopl ();

}

}

void acopl() {

digitalWrite(acoplador, HIGH);

delay(tempo_de_acopl);

digitalWrite(acoplador, LOW);

}




talvez vc nao entenda muito a parte da leitura do resultado, mas ele e parte de um codigo do youtube (caliper digital ) ( https://www.youtube.com/watch?v=dborXvt7DA8)

a unica coisa q nao consigo e ligar por apenas 1 ou 2 segundos o rele que energiza os outros (se ficar ligado, como ele tem um fim ele tranca e queimara)

esse codigo que mandei foi a ultima tentativa que realizei sem sucesso de ligar


se quiser ainda adiciona alguns comentarios no codigo para melhor entender

desde ja agradeço a ajuda

tentei agora utilizar o while para manter desligado, mas ai ele parou o codigo todo

void acopl() {

  


digitalWrite(acoplador, HIGH); 
 
delay(tempo_de_acopl);
 
while(result > 0.00 && result < 2.19){

digitalWrite(acoplador, LOW);
}

Aquilo que te vou sugerir, é uma má prática, mas pode resultar:

void setup()
{
//o campo de setup só é lido uma vez.
}

alkuentrus:
Aquilo que te vou sugerir, é uma má prática, mas pode resultar:

void setup()

{
//o campo de setup só é lido uma vez.
}

Pensei nisso, mas o campo do setup não é lido apenas quando liga o Arduino?
Eu precisava que quando ele lesse outro valor ele ligasse dnv por 1minuto e desligasse, e ligasse novamente só após alterar o valor novamente

...é lido só 1 vez sim... Temos de arranjar outra estratégia.

alkuentrus:
...é lido só 1 vez sim... Temos de arranjar outra estratégia.

Tô a dias quebrando cabeça para descobrir, tentei usar while, do...while o if tbm o break não aceita

Vitor_Brzozkowski:
Tô a dias quebrando cabeça para descobrir, tentei usar while, do...while o if tbm o break não aceita

pelo que testei agora com o do...while ele entra na funçao e para de ler o resultado, como faço para ele continuar lendo quando entrar na funçao?

do {
    digitalWrite(rele1, LOW);

    digitalWrite(rele11, HIGH);

//pensei em mandar ele ler o resultado aqui, mas nao sei como e o codigo que devo escrever

  }while ( result > 2.12 && result < 2.45 );

Vitor_Brzozkowski não sei como vai usa-lo, por isso não entendi.
Mas dá uma olhada nas alterações que fiz, estão marcadas com
/******************************************************************************/

#define acoplador 13

boolean acionaRele = true;/******************************************************************************/
int i;

int sign;

long value;

float result;

int clockpin = 4;

int datapin = 5;

int tempo_de_acopl = 5000;

int rele1 = 12;

int rele11 = 11;

int rele2 = 10;

int rele22 = 9;

int rele3 = 8;

int rele33 = 7;




unsigned long tempmicros;


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {




  Serial.begin(9600);

  pinMode(clockpin, INPUT);

  pinMode(datapin, INPUT);

  pinMode(rele1, OUTPUT);

  pinMode(rele2, OUTPUT);

  pinMode(rele3, OUTPUT);

  pinMode(rele11, OUTPUT);

  pinMode(rele22, OUTPUT);

  pinMode(rele33, OUTPUT);

  pinMode(acoplador,OUTPUT);   

}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop () {





  while (digitalRead(clockpin) == HIGH) {} //if clock is LOW wait until it turns to HIGH

  tempmicros = micros();

  while (digitalRead(clockpin) == LOW) {} //wait for the end of the HIGH pulse

  if ((micros() - tempmicros) > 500) { //if the HIGH pulse was longer than 500 micros we are at the start of a new bit sequence

    decode(); //decode the bit sequence

  }



}



void decode() {

  sign = 1;

  value = 0;

  for (i = 0; i < 23; i++) {

    while (digitalRead(clockpin) == HIGH) { } //wait until clock returns to HIGH- the first bit is not needed

    while (digitalRead(clockpin) == LOW) {} //wait until clock returns to LOW

    if (digitalRead(datapin) == LOW) {

      if (i < 20) {

        value |= 1 << i;

      }

      if (i == 20) {

        sign = -1;

      }

    }

  }



  ///////////////////////////////////////////////////////////////////////////////////////////////////////////

  result = (value * sign) / 3856.8376068376;

  Serial.println(result, 2); //print result with 2 decimals

  delay(5);

  if ( result > 2.12 && result < 2.45 ) {
    /******************************************************************************/
    if (acionaRele == true){
      digitalWrite(rele1, HIGH);

      digitalWrite(rele11, LOW);

      acionaRele = false;      
    }
    /******************************************************************************/

  }
  else {

    digitalWrite(rele1, LOW);

    digitalWrite(rele11, HIGH);

 
  }

  if ( result > 2.45 && result < 3.19 ) {


    digitalWrite(rele3, HIGH);

    digitalWrite(rele33, HIGH);

 

  }
  else {


    digitalWrite(rele3, LOW);

    digitalWrite(rele33, HIGH);


  }













 if ( result > 2.12 && result < 3.19 ) {


    digitalWrite(rele2, LOW);

     digitalWrite(rele22, HIGH);

  }
  else {


    digitalWrite(rele2, HIGH);

     digitalWrite(rele22, LOW);


 
  }















//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


if ( result > 2.12 && result < 2.45 ) {


  acopl ();
  }



if ( result > 2.45 && result < 3.19 ) {

acopl ();
 
}
 
 if ( result > 0.00 && result < 2.12) {

  acopl ();

 
 }


 if ( result > 3.19 && result < 10.00) {

  acopl ();

 }



}

void acopl() {

 


digitalWrite(acoplador, HIGH);
 
delay(tempo_de_acopl);

digitalWrite(acoplador, LOW);


 
}

tecdiego:
Vitor_Brzozkowski não sei como vai usa-lo, por isso não entendi.
Mas dá uma olhada nas alterações que fiz, estão marcadas com
/******************************************************************************/

#define acoplador 13

boolean acionaRele = true;/******************************************************************************/
int i;

int sign;

long value;

float result;

int clockpin = 4;

int datapin = 5;

int tempo_de_acopl = 5000;

int rele1 = 12;

int rele11 = 11;

int rele2 = 10;

int rele22 = 9;

int rele3 = 8;

int rele33 = 7;

unsigned long tempmicros;

///////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {

Serial.begin(9600);

pinMode(clockpin, INPUT);

pinMode(datapin, INPUT);

pinMode(rele1, OUTPUT);

pinMode(rele2, OUTPUT);

pinMode(rele3, OUTPUT);

pinMode(rele11, OUTPUT);

pinMode(rele22, OUTPUT);

pinMode(rele33, OUTPUT);

pinMode(acoplador,OUTPUT);

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop () {

while (digitalRead(clockpin) == HIGH) {} //if clock is LOW wait until it turns to HIGH

tempmicros = micros();

while (digitalRead(clockpin) == LOW) {} //wait for the end of the HIGH pulse

if ((micros() - tempmicros) > 500) { //if the HIGH pulse was longer than 500 micros we are at the start of a new bit sequence

decode(); //decode the bit sequence

}

}

void decode() {

sign = 1;

value = 0;

for (i = 0; i < 23; i++) {

while (digitalRead(clockpin) == HIGH) { } //wait until clock returns to HIGH- the first bit is not needed

while (digitalRead(clockpin) == LOW) {} //wait until clock returns to LOW

if (digitalRead(datapin) == LOW) {

if (i < 20) {

value |= 1 << i;

}

if (i == 20) {

sign = -1;

}

}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

result = (value * sign) / 3856.8376068376;

Serial.println(result, 2); //print result with 2 decimals

delay(5);

if ( result > 2.12 && result < 2.45 ) {
    /******************************************************************************/
    if (acionaRele == true){
      digitalWrite(rele1, HIGH);

digitalWrite(rele11, LOW);

acionaRele = false;     
    }
    /******************************************************************************/

}
  else {

digitalWrite(rele1, LOW);

digitalWrite(rele11, HIGH);

}

if ( result > 2.45 && result < 3.19 ) {

digitalWrite(rele3, HIGH);

digitalWrite(rele33, HIGH);

}
  else {

digitalWrite(rele3, LOW);

digitalWrite(rele33, HIGH);

}

if ( result > 2.12 && result < 3.19 ) {

digitalWrite(rele2, LOW);

digitalWrite(rele22, HIGH);

}
  else {

digitalWrite(rele2, HIGH);

digitalWrite(rele22, LOW);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

if ( result > 2.12 && result < 2.45 ) {

acopl ();
  }

if ( result > 2.45 && result < 3.19 ) {

acopl ();

}

if ( result > 0.00 && result < 2.12) {

acopl ();

}

if ( result > 3.19 && result < 10.00) {

acopl ();

}

}

void acopl() {

digitalWrite(acoplador, HIGH);

delay(tempo_de_acopl);

digitalWrite(acoplador, LOW);

}

Infelizmente ficou igual, não mudou

Descreve aí exatamente oq você quer fazer ou comenta linha a linha seu código, pois pelo que entendi, oq eu postei só aciona o dele uma vez

Como diz o tecdiego, de facto tens de explicar bem o que queres fazer. Se explicares bem, passo por passo, facilitas a correcção do código.

tecdiego:
Descreve aí exatamente oq você quer fazer ou comenta linha a linha seu código, pois pelo que entendi, oq eu postei só aciona o dele uma vez

entendi o que vc fez, só que acho q no programa inteiro ele só roda 1x né
Mesmo se sair do valor e voltar depois para os valores, retirei umas linhas extras e testarei novamente

(Para ele voltar ao estado de acionamento no

else{
}

Eu não deveria colocar um

AcionaRele = true;

Eu testarei assim que possível, mas só para ter certeza mesmo se posso fazer isso

Testei aqui o seu código, tá chegando perto hehee
Do jeito q vc colocou ele entra na medida e aciona o relé (mas não desliga, teria q desligar entre 1 e 5 segundos) e quando sai ele não aciona de volta

Aí adicionei o

 AcionaRele = true

No else, aí quando entra ele liga( mas continua ligado, tentei colocar delay mas não adiantou) aí sai ele desliga
E se entrar de novo ele liga

A única coisa q falta agora é desligar entre 1s e 5s depois que acionar o rele

boolean acionaRele = true;/******************************************************************************/

int i;

int sign;

long value;

float result;

int clockpin = 4;

int datapin = 5;

int releX = 13;

int rele11 = 11;

int rele2 = 10;

int rele22 = 9;

int rele3 = 8;

int rele33 = 7;




unsigned long tempmicros;


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {




  Serial.begin(9600);

  pinMode(clockpin, INPUT);

  pinMode(datapin, INPUT);

  pinMode(releX, OUTPUT);

  pinMode(rele2, OUTPUT);

  pinMode(rele3, OUTPUT);

  pinMode(rele11, OUTPUT);

  pinMode(rele22, OUTPUT);

  pinMode(rele33, OUTPUT);



}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop () {





  while (digitalRead(clockpin) == HIGH) {} //if clock is LOW wait until it turns to HIGH

  tempmicros = micros();

  while (digitalRead(clockpin) == LOW) {} //wait for the end of the HIGH pulse

  if ((micros() - tempmicros) > 500) { //if the HIGH pulse was longer than 500 micros we are at the start of a new bit sequence

    decode(); //decode the bit sequence

  }



}


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////

void decode() {

  sign = 1;

  value = 0;

  for (i = 0; i < 23; i++) {

    while (digitalRead(clockpin) == HIGH) { } //wait until clock returns to HIGH- the first bit is not needed

    while (digitalRead(clockpin) == LOW) {} //wait until clock returns to LOW

    if (digitalRead(datapin) == LOW) {

      if (i < 20) {

        value |= 1 << i;

      }

      if (i == 20) {

        sign = -1;

      }

    }

  }




  result = (value * sign) / 3856.8376068376;

  Serial.println(result, 2); //print result with 2 decimals

  delay(5);


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////

  if ( result > 2.12 && result < 2.45 ) {
    /******************************************************************************/
    if (acionaRele == true){
      digitalWrite(releX, HIGH);
delay(1000);
      digitalWrite(releX, LOW);
delay(10);


 acionaRele = false;  
          
    }
   




  }




  
  else {

acionaRele = true;  

 
  }
 




}

esta funcionando assim, mas so com 1 das tolerancias, se eu adicionar mais uma.

exemplo:

  if ( result > 2.12 && result < 2.45 ) {
    /******************************************************************************/
    if (acionaRele == true){
      digitalWrite(releX, HIGH);
delay(1000);
      digitalWrite(releX, LOW);
delay(10);


 acionaRele = false;  
          
    }
   




  }




  
  else {

acionaRele = true;  

 
  }
 




  if ( result > 2.45 && result < 3.19 ) {
    /******************************************************************************/
    if (acionaRele == true){
      digitalWrite(releX, HIGH);
delay(1000);
      digitalWrite(releX, LOW);
delay(10);


 acionaRele = false;  
          
    }
   




  }




  
  else {

acionaRele = true;  

 
  }
 




}

o codigo entra em loop, e pisca ligando e desligando o rele (eu entendo o pq do loop mas nao sei escrever algo que pare isso)

Testa aí

#define acoplador 13

boolean acionaRele = true;/******************************************************************************/
int intervaloRele;/******************************************************************************/
int i;

int sign;

long value;

float result;

int clockpin = 4;

int datapin = 5;

int tempo_de_acopl = 5000;

int rele1 = 12;

int rele11 = 11;

int rele2 = 10;

int rele22 = 9;

int rele3 = 8;

int rele33 = 7;




unsigned long tempmicros;


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {




  Serial.begin(9600);

  pinMode(clockpin, INPUT);

  pinMode(datapin, INPUT);

  pinMode(rele1, OUTPUT);

  pinMode(rele2, OUTPUT);

  pinMode(rele3, OUTPUT);

  pinMode(rele11, OUTPUT);

  pinMode(rele22, OUTPUT);

  pinMode(rele33, OUTPUT);

  pinMode(acoplador,OUTPUT);   

}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop () {





  while (digitalRead(clockpin) == HIGH) {} //if clock is LOW wait until it turns to HIGH

  tempmicros = micros();

  while (digitalRead(clockpin) == LOW) {} //wait for the end of the HIGH pulse

  if ((micros() - tempmicros) > 500) { //if the HIGH pulse was longer than 500 micros we are at the start of a new bit sequence

    decode(); //decode the bit sequence

  }



}



void decode() {

  sign = 1;

  value = 0;

  for (i = 0; i < 23; i++) {

    while (digitalRead(clockpin) == HIGH) { } //wait until clock returns to HIGH- the first bit is not needed

    while (digitalRead(clockpin) == LOW) {} //wait until clock returns to LOW

    if (digitalRead(datapin) == LOW) {

      if (i < 20) {

        value |= 1 << i;

      }

      if (i == 20) {

        sign = -1;

      }

    }

  }



  ///////////////////////////////////////////////////////////////////////////////////////////////////////////

  result = (value * sign) / 3856.8376068376;

  Serial.println(result, 2); //print result with 2 decimals

  delay(5);
  if ((intervaloRele + 3000) <= millis()){
    
    digitalWrite(rele1, LOW);

    digitalWrite(rele11, HIGH);

    acionaRele = true;     
  }

  if ( result > 2.12 && result < 2.45 ) {
    /******************************************************************************/
    if (acionaRele == true){
      digitalWrite(rele1, HIGH);

      digitalWrite(rele11, LOW);

      acionaRele = false;     
      intervaloRele = millis();
    }
    /******************************************************************************/

  }
  else {

    digitalWrite(rele1, LOW);

    digitalWrite(rele11, HIGH);

 
  }

  if ( result > 2.45 && result < 3.19 ) {


    digitalWrite(rele3, HIGH);

    digitalWrite(rele33, HIGH);

 

  }
  else {


    digitalWrite(rele3, LOW);

    digitalWrite(rele33, HIGH);


  }













 if ( result > 2.12 && result < 3.19 ) {


    digitalWrite(rele2, LOW);

     digitalWrite(rele22, HIGH);

  }
  else {


    digitalWrite(rele2, HIGH);

     digitalWrite(rele22, LOW);


 
  }















//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


if ( result > 2.12 && result < 2.45 ) {


  acopl ();
  }



if ( result > 2.45 && result < 3.19 ) {

acopl ();
 
}
 
 if ( result > 0.00 && result < 2.12) {

  acopl ();

 
 }


 if ( result > 3.19 && result < 10.00) {

  acopl ();

 }



}

void acopl() {

 


digitalWrite(acoplador, HIGH);
 
delay(tempo_de_acopl);

digitalWrite(acoplador, LOW);


 
}

tecdiego:
Testa aí

#define acoplador 13

boolean acionaRele = true;//
int intervaloRele;/
/
int i;

int sign;

long value;

float result;

int clockpin = 4;

int datapin = 5;

int tempo_de_acopl = 5000;

int rele1 = 12;

int rele11 = 11;

int rele2 = 10;

int rele22 = 9;

int rele3 = 8;

int rele33 = 7;

unsigned long tempmicros;

///////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {

Serial.begin(9600);

pinMode(clockpin, INPUT);

pinMode(datapin, INPUT);

pinMode(rele1, OUTPUT);

pinMode(rele2, OUTPUT);

pinMode(rele3, OUTPUT);

pinMode(rele11, OUTPUT);

pinMode(rele22, OUTPUT);

pinMode(rele33, OUTPUT);

pinMode(acoplador,OUTPUT);

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop () {

while (digitalRead(clockpin) == HIGH) {} //if clock is LOW wait until it turns to HIGH

tempmicros = micros();

while (digitalRead(clockpin) == LOW) {} //wait for the end of the HIGH pulse

if ((micros() - tempmicros) > 500) { //if the HIGH pulse was longer than 500 micros we are at the start of a new bit sequence

decode(); //decode the bit sequence

}

}

void decode() {

sign = 1;

value = 0;

for (i = 0; i < 23; i++) {

while (digitalRead(clockpin) == HIGH) { } //wait until clock returns to HIGH- the first bit is not needed

while (digitalRead(clockpin) == LOW) {} //wait until clock returns to LOW

if (digitalRead(datapin) == LOW) {

if (i < 20) {

value |= 1 << i;

}

if (i == 20) {

sign = -1;

}

}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

result = (value * sign) / 3856.8376068376;

Serial.println(result, 2); //print result with 2 decimals

delay(5);
  if ((intervaloRele + 3000) <= millis()){
   
    digitalWrite(rele1, LOW);

digitalWrite(rele11, HIGH);

acionaRele = true;   
  }

if ( result > 2.12 && result < 2.45 ) {
    /******************************************************************************/
    if (acionaRele == true){
      digitalWrite(rele1, HIGH);

digitalWrite(rele11, LOW);

acionaRele = false;   
      intervaloRele = millis();
    }
    /******************************************************************************/

}
  else {

digitalWrite(rele1, LOW);

digitalWrite(rele11, HIGH);

}

if ( result > 2.45 && result < 3.19 ) {

digitalWrite(rele3, HIGH);

digitalWrite(rele33, HIGH);

}
  else {

digitalWrite(rele3, LOW);

digitalWrite(rele33, HIGH);

}

if ( result > 2.12 && result < 3.19 ) {

digitalWrite(rele2, LOW);

digitalWrite(rele22, HIGH);

}
  else {

digitalWrite(rele2, HIGH);

digitalWrite(rele22, LOW);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

if ( result > 2.12 && result < 2.45 ) {

acopl ();
  }

if ( result > 2.45 && result < 3.19 ) {

acopl ();

}

if ( result > 0.00 && result < 2.12) {

acopl ();

}

if ( result > 3.19 && result < 10.00) {

acopl ();

}

}

void acopl() {

digitalWrite(acoplador, HIGH);

delay(tempo_de_acopl);

digitalWrite(acoplador, LOW);

}

Bah não funcionou, acho q vou desistir do projeto, esse q você me mandou deixa ligado continuamente igual o anterior, mas obrigado pela ajuda, o problema agora é quando coloco mais 1 tolerância ele trava o sistema, pensei em usar goto mas aí ele ia só ficar reiniciando e ligaria novamente o relé , tem como usar 1 "else" para vários "If"?

Diz oq você quer fazer! Assim podemos fazer o código do zero!