Codigo para controlar motor con encoder

Hola a todos,

Les cuento que quiero ponerle un motor a un toldo /parasol / marquesina que se enrolla. Ya tengo diseñada la caja de engranajes, el motor… Con mucho gusto luego lo pondre como miniproyecto en la seccion proyectos y ahi podran ver todos los detalles.

La idea es que con un boton suba, que con otro boton baje. Al eje del motor le pongo un encoder EC11 (datasheet adjunto), para que me mira la cantidad de pasos y pueda con eso saber cuándo parar el motor.
Como es un encoder relativo, tambien tengo un boton de homing, para que haga coincidir los pasos del encoder con la posicion cero. Esto lo hago con un fin de carrera al principio del recorrido.
El motor puede ir en un sentido u otro (subir y bajar), cada uno con un relay.

Para leer un encoder uso la biblioteca Encoder.h de Paul Stoffregen y esa biblioteca me guarda los pasos en la variable “newPosition”

Aqui el codigo que hice:

#include <Encoder.h>

Encoder myEnc(5, 6);


//Pulsadores
byte botonhome    = 8;
byte botoncerrado = 2;
byte botonamedias = 3;
byte botonabrir   = 7;
byte fincarrerahome = 9;

//Relays
byte relaysube    = 1;
byte relaybaja    = 4;

//Variables de estado:
int estado = 0;  // 0 -> reposo , 1->homing,  5->cerrando, 6->abriendo

void setup() {
  Serial.begin(9600);
  Serial.println("Control de motor con encoder:");

  //Pins de relay al principio
  pinMode(relaysube, OUTPUT); digitalWrite(relaysube, HIGH);
  pinMode(relaybaja, OUTPUT); digitalWrite(relaybaja, HIGH);

  //Pins de pulsadores al principio
  pinMode(botonhome, INPUT_PULLUP);
  pinMode(botoncerrado, INPUT_PULLUP);
  pinMode(botonamedias, INPUT_PULLUP);
  pinMode(botonabrir, INPUT_PULLUP);
}

long oldPosition  = -999;

void loop() {
  long newPosition = myEnc.read();
  if (newPosition != oldPosition)  {
                                      oldPosition = newPosition;
                                      Serial.println(newPosition);
                                   }
  if (!digitalRead(botoncerrado))  {  
                                      Serial.print("botoncerrado apretado"); 
                                      estado = 5; 
                                   }
  if (!digitalRead(botonabrir))    {  
                                      Serial.print("botonabrir apretado"); 
                                      estado = 6; 
                                   }
  if (!digitalRead(botonhome))     {  
                                      Serial.print("botonhome apretado"); 
                                      estado = 1; 
                                   }
  if (estado == 5)                 {   
                                      while (newPosition > 0) {digitalWrite(relaysube, LOW); digitalWrite(relaybaja, HIGH); Serial.print("Estoy cerrando "); }
                                   }
  if (estado == 6)                 {   
                                      while (newPosition < 10000) {digitalWrite(relaybaja, LOW); digitalWrite(relaysube, HIGH); Serial.print("Estoy abriendo "); }
                                   }
  if (estado == 1)                 {   
                                      while (!digitalRead(fincarrerahome)) {digitalWrite(relaysube, LOW); digitalWrite(relaybaja, HIGH); Serial.print("Homing.... "); }
                                   }
                                   
}

Y aqui un modesto esquema que habia empezado con la PC, pero veo que es mejor dibujarlo:

Mis preocupaciones son:

  • Si se va la luz, el arduino se resetea y pierde los pasos. Por lo que debería hacer un homing al principio.-> será que hago un homing al principio cada vez que el arduino se encienda?? Opiniones bienvenidas :slight_smile:

  • Me gustaria poder tener un solo boton que cambie las variables de estado al hacer click, doble click o mentenerlo, asi me ahorro botones, pines, cableado. Estoy intentando poner en paralelo otra biblioteca, la GitHub - mathertel/OneButton: An Arduino library for using a single button for multiple purpose input. aun no lo he logrado, pero seguiré.

  • Deberia cambiar algo en el código? O encararlo de otra manera?

Muchas gracias!

Tigrecito.

Datasheet Encoder.pdf (917 KB)

  • Si se va la luz, el arduino se resetea y pierde los pasos. Por lo que debería hacer un homing al principio.-> será que hago un homing al principio cada vez que el arduino se encienda?? Opiniones bienvenidas :slight_smile:

Porque no implementas entonces una UPS o SAI (como la llames) para el sistema arduino?
Un sistema asi te permitiría almacenar la información en caso de detectar que te quedas sin energía.
No tiene que ser gran cosa, solo lo necesario para detectar que se cortó la energía, y que puedas salvar la posición. Son milisegundos.
Alguien ha hecho un buen sistema de almacenamiento usando un gran capacitor. Solo te queda detectar rápidamente que no hay energía.
SI usas el detector de fase (indicado en la sección Documentación) en 10 mseg te enteras que no hay energía.
Tu capacitor digamos debería guardar lo suficiente como para que el arduino tenga cuantós milisegundos, supongo que muy pocos, otros 10 o 20 y con eso salvas en la EEPROM el dato y listo.

  • Me gustaria poder tener un solo boton que cambie las variables de estado al hacer click, doble click o mentenerlo,

Un botón puede usarse para que con cada flanco hagas una secuencia diferente o lo que bien seguir tu idea con esa librería como nos has contado.

Hola surbyte!

Muchas gracias por la respuesta! Muy buenas ideas.

OK, entonces tengo que hacer 3 cosas:

  1. Que un boton haga multiples cosas
  2. Leer la documentacion del detector de fase.
  3. Aprender a guardar en la EEPROM.

Aunque luego de decir esto, pienso que podria guardar regularmente en la EEPROM, ponele cada 200 ms, y asi no tendria que poner un detector de fase... A lo sumo pierdo como máximo los pasos de 200 ms, que para un toldo es como si nada. Asi que primero empezaré por el Boton, Luego por la EEPROM y luego veré si necesito el detector de fase.

Saludos!
Tigrecito

Hola, estuve investigando un poco y guardar cada 200 ms en la EEPROM no sirve, ya que la vida util de una EEPROM es de 100.000 Ciclos Aqui esta la fuente

Por lo que lo primero que tengo que hacer es averiguar por el detector de fase...

Hola, he logrado agregar la biblioteca del Boton. Les comparto el código. Lo probé con dos relays, el encoder y funciona muy bien (aun no me lo creo) :slight_smile: :

#include <OneButton.h>
#include <Encoder.h>

Encoder myEnc(5, 6);

//Pulsadores
OneButton button1(A1, true);

//Relays
byte relaysube    = 2;
byte relaybaja    = 3;

//Variable de estado:
int estado = 0;  // 0->reposo; 1->cerrando, 2->abriendo 

void setup() {
  Serial.begin(9600);
  Serial.println("Control de motor con encoder:");
  Serial.println("Starting TwoButtons...");

  // Esto es para la libreria que detecta click simple o doble click
  button1.attachClick(click1);
  button1.attachDoubleClick(doubleclick1);

  //Pins de relay al principio
  pinMode(relaysube, OUTPUT); digitalWrite(relaysube, HIGH);
  pinMode(relaybaja, OUTPUT); digitalWrite(relaybaja, HIGH);

}

// Esto es de la libreria que lee el encoder
long oldPosition  = -999;

void loop() {
    // Esto es para la libreria del boton, para registrar los ticks.
  button1.tick();
   // Esto lee los pasos del encoder
  long newPosition = myEnc.read();
  
  if (newPosition != oldPosition)  {
                                      oldPosition = newPosition;
                                      Serial.println(newPosition);
                                   }
  //Terminó de actualizar los pasos del encoder y los guardó en "newPosition".
                                   
  if (estado == 1) {
                    if (newPosition > 0)   {  
                                            digitalWrite(relaysube, LOW); digitalWrite(relaybaja, HIGH);                                            
                                           }  else { estado = 0; }     
                   }                        
                                           
  if (estado == 2) {
                    if (newPosition < 100) {  
                                            digitalWrite(relaybaja, LOW); digitalWrite(relaysube, HIGH); 
                                           }   else { estado = 0; } 
                   }

  if (estado == 0) {  
                                            digitalWrite(relaybaja, HIGH); digitalWrite(relaysube, HIGH);
                   }
                   
}


void click1() {
               Serial.println("Cerrado activado");
               estado = 1; 
              } // click1


void doubleclick1() {
                Serial.println("Doble click recibido, Abriendo activado");
                estado = 2; 
                } // doubleclick1

Ahora lo que intentaré hacer es detectar cuando se va el voltaje de alimentacion, y ahi con un capacitor guardar los pasos del encoder en la eeprom. Estuve viendo que deberia guardar un integer, por lo que debo usar mas de un byte. Intentare buscar alguna biblioteca o codigo que lo haga…

En cuanto al detector de fase, estuve viendo alguna informacion el foro aqui … debo investigar mas.

lo guardas con
EEPROM.put(direccion, valor);
y lo lees en el setup al arrancar con

EEPROM.get(direccion, valor);

Buenas:

¿No vale usar esto abajo también?

Guardar:

EEPROM.write(direccion, valor);

Leer:

EEPROM.read(direccion, valor);

Saludos.

No, porque si es un entero, necesitas dos bytes.

EEPROM.read y EEPROM.write son para operaciones de byte
EEPROM.get y EEPROM.put son para operaciones de cualquier tamaño, por eso le dices que vas a leer.

imagina que tienes un dato como newpos del tipo long newPosition

@Tigrecito te recomiendo que la definas como global y no local pero mas allá de eso.

las operaciones con .get y .put son fáciles si no hay nada mas que leer.

lees asi

EEPROM.get(direccion, newPosition);

en realidad estas leyendo 4 bytes que son los 32 bits del long en realidad 31 mas signo.

y como guardas pues de igual modo

EEPROM.put(direccion, newPosition);

donde dirección será algo como 0 por ejemplo o lo que gustes

int direccion = 0; // definida como global tambien.

El tema es que si tuvieras mas datos que guardar entonces debes saber cuantos bytes ocupaste con tu variable inicial y para eso usas sizeof(newPosition) y lo sumas a la direccion inicial

Asi que si tuvieras que guardar OTRO dato, del tipo que fuera harias esto

direccion += sizefo(newPosition);
EEPROM.put(direccion, nuevaVariable);

esto te desplaza a la posicion 4. Empezaste en 0 ocupaste 0 1 2 y 3 con long y luego sigues en 4 en adelante.

Hola surbyte y Metaconta,

primero gracias por la ayuda!!

Bueno luego de luchar 3 horas con la libreria EEPROM, pude lograr que me registre la posicion ultima, y ahi convertir por medio de software un encoder relativo en una absoluto :slight_smile: :slight_smile:

Solo tengo una duda: despues de EEPROM.put hace falta poner un delay de 10 ms? se que el comando se toma 3,3 ms en guardar… no seria necesiario ya que primero termina de guardar, y luego ejecuta el delay… no?

Para simular el guardado ultilizo el “mantener presionado” -longpressstart de la biblioteca de Button. En vez de eso, luego debo pensar que eso me lo active el corte de luz.

Para el detectar que se fue la luz pensé que puedo alimentar constantemente un Pin del arduino y que cuando detecta la baja de tension en ese pin, que ejecute el guardado, sostenido por un capacitor en paralelo, conectado entre VIN y GND en el arduino. Pienso entrarle al pin del arduino con 3.3 Volt, poniendo un regulador AMS1117, o bien un octoacoplador, como para que si llega a haber un pico de tension no lo queme. Ta bien no?

bueno aca el codigo. Sugerencias bienvenidas obviamente :slight_smile:

#include <EEPROM.h>
#include <OneButton.h>
#include <Encoder.h>

Encoder myEnc(5, 6);

//Pulsadores
OneButton button1(A1, true);


//Pin deteccion voltaje presente
byte deteccion_voltaje = 6;
//delay (200); //se estabiliza la tension en pin de deteccion de tension

//Relays
byte relaysube    = 2;
byte relaybaja    = 3;

//Variable de estado:
int estado = 0;  // 0->reposo; 1->cerrando, 2->abriendo -> 9 -> guardando en EEPROM

//variable donde se guardan los pasos del encoder
int newPosition = 0;
int lastsavedposition = 0;

//variable donde se indica en que direccion de la EEPROM guardar
int direccion = 0;

// Esto es de la libreria que lee el encoder
int oldPosition  = -999;

void setup() {
  Serial.begin(9600);
  Serial.println("Control de motor con encoder:");
  Serial.println("Starting TwoButtons...");

  // Esto es para la libreria que detecta click simple o doble click
  button1.attachClick(click1);
  button1.attachDoubleClick(doubleclick1);
  button1.attachLongPressStart(longPressStart1);
  //button1.attachLongPressStop(longPressStop1);
  //button1.attachDuringLongPress(longPress1);

  //Pins de relay al principio
  pinMode(relaysube, OUTPUT); digitalWrite(relaysube, HIGH);
  pinMode(relaybaja, OUTPUT); digitalWrite(relaybaja, HIGH);

  //pin de deteccion de voltaje
  pinMode(deteccion_voltaje, INPUT_PULLUP);


//aca se lee el ultimo valor guardado en la EEPROM y se lo asigna a la varible newPosition del encoder
EEPROM.get(direccion, lastsavedposition);
Serial.println("Desde EEPROM:" );
Serial.println(lastsavedposition);
}


void loop() {
    // Esto es para la libreria del boton, para registrar los ticks.
  button1.tick();
   // Esto lee los pasos del encoder
      newPosition = myEnc.read() + lastsavedposition;
  
  if (newPosition != oldPosition)  {
                                      oldPosition = newPosition;
                                      //Serial.println("Posicion actual:" );
                                      Serial.println(newPosition);
                                   }
  //Terminó de actualizar los pasos del encoder y los guardó en "newPosition".
                                   
  if (estado == 1) {
                    if (newPosition > 0)   {  
                                            digitalWrite(relaysube, LOW); digitalWrite(relaybaja, HIGH);                                            
                                           }  else { estado = 0; }     
                   }                        
                                           
  if (estado == 2) {
                    if (newPosition < 100) {  
                                            digitalWrite(relaybaja, LOW); digitalWrite(relaysube, HIGH); 
                                           }   else { estado = 0; } 
                   }

  if (estado == 0) {  
                                            digitalWrite(relaybaja, HIGH); digitalWrite(relaysube, HIGH);
                   }
  
  if (estado == 9) {  
                                            EEPROM.put(direccion, newPosition);
                                            delay (10); 
                                            estado = 0;
                   }

                   
}


void click1() {
               Serial.println("Cerrado activado");
               estado = 1; 
              } // click1


void doubleclick1() {
                Serial.println("Doble click recibido, Abriendo activado");
                estado = 2; 
                } // doubleclick1

void longPressStart1() {
  Serial.println("Button 1 longPress start");
  estado = 9; 
} // longPressStart1

Ahi van dos fotos. La primera con la posicion del encoder y la segunda con el circuito de prueba…


Para detectar el corte de energía tu arduino debe seguir alimentado por el tiempo que tarde en guardar el dato en la EEPROM, esos 3.3mseg como mínimo. Como ves no es mucho.
Ahora bien, en alguno lado debe haber algo que detecte que se cayó la energia pero tu arduino gracias al capacitor o una bateria sigue funcionando al menos por 10 mseg? Okay… supongamos que es asi.
Como lo quieras implementar es un tema de diseño.
Yo te mencione el detector de AC porque en el peor caso demoras 10mseg en saberlo. En continua cualquier fuente tiene capacitor electrolítico y tenderá a demorar su detección lo que compromete tu capacitor de emergencia.

Buneas:

Cuando estaba en la época de los PIC, hacía esto. Con Arduino no lo he probado, en el fondo es lo mismo.

  1. Creé una fuente de alimentación de 24 VDC. Si le puse mucho. El PIC16F84A con sus compnente son de 5V. Se tarda unos 8 segundos en apagarse todo completo. No llegué a crear uno que dure 2 segundos que es suficiente para grabar la EEPROM.

  2. Cuando pierde la fuente de alimentación principal, se desactiva todos los componentes de Arduino, sea LCD, sensor de Ultrasonido, ventiladores, motorcitos, Led, etc... Menos el propio microcontrolador que te aguante unos 3 segundos, tiempo suficiente para que el microcontrolador le de tiempo en operar que ha perdido la energía y guarde datos en la EERPOM.

  3. Como sabía que la EEPROM tiene vida útil, todo movimiento lo guardaba en la RAM.

  4. Al perder la energía, un optoacoplador conectado al pin de Arduino como entrada digital se apaga. Al detectar el apagado Arduino con un if else, detiene el proceso y movimiento de datos de Arduino, los datos que tiene en la RAM lo guarda en la EEPROM.

  5. Una vez en la EEPROM, Arduino espera su apagado o el encendido del pin si antes llega la corriente.

  6. El condensador que l epuse fue de 63V / 2200 uF. En serio otro condensador más pequeño para cargas rápidas, de paso tiene estabilidad.

No es tan complicado como parece. Puede ver más técnicas.

Saludos.

@surbyte y @Metaconta, geniales observaciones. Gracias.

@surbyte, es verdad, no habia pensado lo de la fuente, que tambien tiene capacitores. Lo tendre en cuenta para mi diseño. Te digo más, veo que me estoy complicando tratando de detectar la caida de la fase. Volvi a ver el ACS712 y realmente es muy simple, creo que vale la pena.

@Metaconta, de acuerdo, algo asi pensaba hacer, pero volvi a releer el post de Detectar caida de fase y casi me convencio de hacerlo asi. Ya he quemado un UNO haciendo experimentos, y por menos de la mitad me compro uno de esos y ya....

Por otra parte necesito agregarle algo mas a mi control de motor: Un "Stallguard"...o en espanol seria un control de "motor frenado o esforzandose de más". Me imagino que puede ser algo que mida la corriente (ojo que es alterna 230 V) y que envie una senal analogica a un pin de entrada del Arduino... Me deberia de enviar una señal cuando la corriente sea +200% de la nominal. Tengo que filtrar la corriente de arranque, pero calculo que es lo puedo filtrar con codigo.... Me estuve informando de las corrientes de arranque con san Google, asi Buscar corriente arranque en google

Me acabo de dar cuenta, sera que lo puedo hacer con el mismo ACS712? Con este de aquí por ejemplo?

Otra manera seria midiendo los pasos por segundos teóricos y los reales, y si detecto menos velocidad, implica que el motor esta andando mas lento, supuestamente por alguna traba... La tension de CA aqui es bastante estable, asi que en teoria el motor deberia mantener su velocidad si no tiene algun impedimento mecánico. Por todas estas variables externas (tension de red, comportamiento mecanico), creo que medir la corriente utilizada seria lo mejor.

Que les parece? alguna recomendación?

Hola:

Detectar frecuencia por cruce por cero.

Con lo que cuenta arriba. Es como las pinzas amperímetra, te detecta la cantidad de corriente.

Una cosa es la cantidad de corriente, otra cosa es cuando hay corriente. En tu caso para lo que quieres, es saber por un pin de Arduino, si hay o no corriente.

Ahí puedes poner un optoacoplador.

Saludos.

Hola Metaconta, tenes toda la razón. Una cosa es cantidad de corriente y otra es detectar si hay corriente, que mejor dicho sería detectar si hay tensión. Tengo que armar las cosas por separado.

Pregunta de principiante: no necesito rectificar con un puente de diodos para entrarle al octoacoplador?

Con este es suficiente.

Onda completa.

Pueden rectificador de onda completa.

Mira esto.

Ver vídeo.
Arduino: Detección corriente alterna (CA) y optoacopladores SIN CÓDIGO! con programación gráfica

Saludos.

Hola Metaconta,

muy bueno. No lo tenia claro, ahora, mucho mejor. Tardare un poco en volver a postear, porque tengo que comprar los octoacopladores, armar el circuito, avanzar con la mecanica del motor, programar el stallguard....

Pero creo que ya tengo muchas herramientas y que ahora las tengo que empezar a usar :wink:

Gracias!!

Cuando tenga todo cocinado o me haya trabado , volvere a postear.

Saludos!!

No senseña fotos del invento.

Cuídate. :grin:

Porque no revistas los tutoriales que tenemos en Documentación, este como tantos temas ha sido conversado hace mucho tiempo.
Recuerda, no eres el primero con este problema. Solo hay que investigar.

Para seguir en la línea que persigues hay que tener pleno conocimiento de lo que estas haciendo.

Eso que te puso @Metaconta esta en un hilo de Documentación, con sumo detalle.
Si usamos el H11AA1, si se usa un 4N25, porque tal resistencia, que pasa con 110/220VAC.
Cómo detecto, cuando detecto, etc, etc.

Hola, me trabé con una parte del código: Quiero reemplazar estos delay por millis. Intenté pero no me compila, me dice que la variable no está declarada, aunque sí lo está. Lo hice comparando con el codigo de los tutoriales de “blink con millis”. Pero aun asi no me compila…

Aca el codigo con delay que quiero reemplazar (compila pero el delay estorba al encoder):

#include <EEPROM.h>
#include <OneButton.h>
#include <Encoder.h>

Encoder myEnc(5, 6);

//Pulsadores
OneButton button1(A1, true);


//Pin deteccion voltaje presente
byte deteccion_voltaje = 6;
//delay (200); //se estabiliza la tension en pin de deteccion de tension

//Relays
byte relaycierra  = 4;
byte relayabre    = 3;

//Variable de estado:
int estado = 0;  // 0->reposo; 1->cerrando, 2->abriendo -> 9 -> guardando en EEPROM

//tiempo de espera para cambio de sentido
unsigned long tiempo;
//tiempo = millis();
  
//variable donde se guardan los pasos del encoder
int newPosition = 0;
int lastsavedposition = 0;

//variable donde se indica en que direccion de la EEPROM guardar
int direccion = 0;

// Esto es de la libreria que lee el encoder
int oldPosition  = -999;

void setup() {
  Serial.begin(9600);
  Serial.println("Control de motor con encoder:");
  Serial.println("Starting TwoButtons...");

  // Esto es para la libreria que detecta click simple o doble click
  button1.attachClick(click1);
  button1.attachDoubleClick(doubleclick1);
  button1.attachLongPressStart(longPressStart1);
  //button1.attachLongPressStop(longPressStop1);
  //button1.attachDuringLongPress(longPress1);

  //Pins de relay al principio
  pinMode(relaycierra, OUTPUT); digitalWrite(relaycierra, HIGH);
  pinMode(relayabre, OUTPUT); digitalWrite(relayabre, HIGH);

  //pin de deteccion de voltaje
  pinMode(deteccion_voltaje, INPUT_PULLUP);


//aca se lee el ultimo valor guardado en la EEPROM y se lo asigna a la varible newPosition del encoder
EEPROM.get(direccion, lastsavedposition);
Serial.println("Desde EEPROM:" );
Serial.println(lastsavedposition);
}


void loop() {
    // Esto es para la libreria del boton, para registrar los ticks.
  button1.tick();
   // Esto lee los pasos del encoder
      newPosition = myEnc.read() + lastsavedposition;
    //Esto es para los temporizadores
    tiempo = millis();
  
  if (newPosition != oldPosition)  {
                                      oldPosition = newPosition;
                                      //Serial.println("Posicion actual:" );
                                      Serial.println(newPosition);
                                   }
  //Terminó de actualizar los pasos del encoder y los guardó en "newPosition".
                                   
  if (estado == 1) {
                    if (newPosition > 0)   { 
                                            digitalWrite(relayabre, HIGH);
                                            delay(1000);  
                                            digitalWrite(relaycierra, LOW);                                             
                                           }  else { estado = 0; }     
                   }                        
                                           
  if (estado == 2) {
                    if (newPosition < 1000) {  
                                            digitalWrite(relaycierra, HIGH); 
                                            delay(1000); 
                                            digitalWrite(relayabre, LOW); 
                                           }   else { estado = 0; } 
                   }

  if (estado == 0) {  
                                            digitalWrite(relayabre, HIGH); digitalWrite(relaycierra, HIGH);
                   }
  
  if (estado == 9) {  
                                            EEPROM.put(direccion, newPosition); 
                                            estado = 0;
                   }

                   
}


void click1() {
               Serial.println("Cerrado activado");
               estado = 1; 
              } // click1


void doubleclick1() {
                Serial.println("Doble click recibido, Abriendo activado");
                estado = 2; 
                } // doubleclick1

void longPressStart1() {
  Serial.println("Button 1 longPress start");
  estado = 9; 
} // longPressStart1

Aca el ejemplo de "blink sin delay"que seguí de la guia de vctorjam https://forum.arduino.cc/index.php?topic=654615.0

Aca mi intento con millis, que no compila:

#include <EEPROM.h>
#include <OneButton.h>
#include <Encoder.h>

Encoder myEnc(5, 6);

//Pulsadores
OneButton button1(A1, true);


//Pin deteccion voltaje presente
byte deteccion_voltaje = 6;
//delay (200); //se estabiliza la tension en pin de deteccion de tension

//Relays
byte relaycierra  = 4;
byte relayabre    = 3;

//Variable de estado:
int estado = 0;  // 0->reposo; 1->cerrando, 2->abriendo -> 9 -> guardando en EEPROM


  
//variable donde se guardan los pasos del encoder
int newPosition = 0;
int lastsavedposition = 0;

//variable donde se indica en que direccion de la EEPROM guardar
int direccion = 0;

// Esto es de la libreria que lee el encoder
int oldPosition  = -999;

void setup() {
  Serial.begin(9600);
  Serial.println("Control de motor con encoder:");
  Serial.println("Starting TwoButtons...");

  
//tiempo de espera para cambio de sentido

unsigned long t;

  // Esto es para la libreria que detecta click simple o doble click
  button1.attachClick(click1);
  button1.attachDoubleClick(doubleclick1);
  button1.attachLongPressStart(longPressStart1);
  //button1.attachLongPressStop(longPressStop1);
  //button1.attachDuringLongPress(longPress1);

  //Pins de relay al principio
  pinMode(relaycierra, OUTPUT); digitalWrite(relaycierra, HIGH);
  pinMode(relayabre, OUTPUT); digitalWrite(relayabre, HIGH);

  //pin de deteccion de voltaje
  pinMode(deteccion_voltaje, INPUT_PULLUP);


//aca se lee el ultimo valor guardado en la EEPROM y se lo asigna a la varible newPosition del encoder
EEPROM.get(direccion, lastsavedposition);
Serial.println("Desde EEPROM:" );
Serial.println(lastsavedposition);
}


void loop() {
    // Esto es para la libreria del boton, para registrar los ticks.
  button1.tick();
   // Esto lee los pasos del encoder
      newPosition = myEnc.read() + lastsavedposition;
    //Esto es para los temporizadores
t = millis();
  
  if (newPosition != oldPosition)  {
                                      oldPosition = newPosition;
                                      //Serial.println("Posicion actual:" );
                                      Serial.println(newPosition);
                                   }
  //Terminó de actualizar los pasos del encoder y los guardó en "newPosition".
                                   
  if (estado == 1) {
                    if (newPosition > 0)   { 
                                            digitalWrite(relayabre, HIGH);
                                            if ( millis() - t > 200) {  
                                                                              digitalWrite(relaycierra, LOW);
                                                                              t = millis();}                                            
                                           }  else { estado = 0; }     
                   }                        
                                           
  if (estado == 2) {
                    if (newPosition < 1000) {  
                                            digitalWrite(relaycierra, HIGH); 
                                            if ( millis() - t > 200) { 
                                                                              digitalWrite(relayabre, LOW);
                                                                              t = millis();}
                                           }   else { estado = 0; } 
                   }

  if (estado == 0) {  
                                            digitalWrite(relayabre, HIGH); digitalWrite(relaycierra, HIGH);
                   }
  
  if (estado == 9) {  
                                            EEPROM.put(direccion, newPosition); 
                                            estado = 0;
                   }

                   
}


void click1() {
               Serial.println("Cerrado activado");
               estado = 1; 
              } // click1


void doubleclick1() {
                Serial.println("Doble click recibido, Abriendo activado");
                estado = 2; 
                } // doubleclick1

void longPressStart1() {
  Serial.println("Button 1 longPress start");
  estado = 9; 
} // longPressStart1

Desde ya muchas gracias por la ayuda, saludos!

Tu error era este

unsigned long t;

definido en el setup y por eso en el loop() no es reconocido

Colocalo como variable global