Componentes para eliminar ruido en mi circuito

Hola, buenas tardes a todos!, estoy trabajando en un proyecto sobre una maquina de tejido romboidal automática, soy novato en el tema y en el proceso me tope con muchos problemas, uno de ellos es el de ruido, en un principio arme todo el circuito en un solo tablero y sin puesta a tierra, resulto que dañe de forma permanente el arduino, ahora estoy rehaciendo todo teniendo en cuenta los consejos de otros hilos en los que investigue, lo que me queda en duda y no termino de entender, es como disponer en el circuito todos los elementos para eliminar el ruido del mismo, estaría agradecido si pueden orientarme con eso, adjunto un esquema chapuza, perdonen si no se entiende mucho, como dije, soy novato en el tema y quiero aprender para mejorar, muchas gracias!.

El circuito es separado en dos tableros.

Hi,
Yo simpre aconsejo de usar relays solid state para enegizar motores AC. Esto vienen con opto coupler , cruze de zero y con snobbers. Usandos estos te van a reducir el ruido electromanectico que se genera cuanndo energiza un componente que es inductivo y a la vezusando opto couplers en los relays te aisla el MEGA de estos ruidos. Mantener los cables de alto voltaje lejos del MEGA. Tambien tratar de no usar power supplies de los que se conocen "Wall charger " para alimentar el MEGA o accesorios.

Hola tauro!, gracias por responder!, voy a probar comprando relays ssr como me comentas, estaba leyendo sobre los snubber también, pero no se como posicionarlos en el circuito ni de qué valores deberían ser los componentes según el tipo de motor que estoy usando.

Hi,
Algunos de los SSR incorporan ya los snubbers. Tambien debes de compra los SSR relays que se energizen en el punto de zero. Esto no van a producir ruidos electromegneticos ya que el relay es energizado cuando no hay voltaje y esto miniisa los ruidos. Adjunto un link que expliaca en detaiiado el proposito de que los relays sean "cruse de zero". Tambien incluyo un link que demuestra que SSR ya el snubber esta incluido

[Zero-crossing solid state relay - OMCH]
https://scienceprog.com/considering-solid-state-relays-ssr-for-your-projects/

Gracias tauro, voy a aplicar lo de los ssr, otra cosa que tengo duda es un sensor óptico lm393 que está posicionado Justo debajo al eje del motor monofasico, el cual cuenta las vueltas que da el mismo, este sensor puede verse afectado por el campo generado por el motor?, si es así, que deberia usar para evitar que afecte su funcionamiento?, muchas gracias!!

Hi,
hice un google buscando informacion del sensor lm393 pero segun el resultado dice que es un op-amp. Posiblemente es un error y debes de verificarlo.

El LM393 es parte del circuito del sensor.

EL LM393 es un Schmitt trigger, o sea un comparador.

Hi,
No se que distancia esta el sensor del MEGA pero creo que usando cable trensado con shield no vaz a tener problema. En la practica cuando se usa cable con shield solamente el shield se lleva a ground a lado donde suple el voltaje que seria el sensor y el otro lado se deja sin conectar o flotando.

Creo que @Surbyte no se percató pero esto es doble posteo. Ya creaste otro hilo Consejos contra interferencias electromagnéticas con Arduino y otros componentes con la misma pregunta y misma situación. Obviamente prepárate para la regañina.

Ahora mis consejos.

Organiza el "armario". Lo que sea potencia por un lado, alimentación por otro y el Arduino por otro, claro está que utilizar la caja de un ordenador no es la mejor opción por el limite de tamaño. El objetivo es "alejar" el Arduino de las fuentes de ruido.

Si consigues los relés SSR nada, si no lo consigues debes proteger la bobina del contactor con un varistor.

En el esquema solo veo el sensor óptico, pero debe haber seguro mas entradas como botones ¿cuántas y como realizas la conexión?

Hola @victorjam! gracias por responder, quizás parecen iguales los post, pero en este quería consultar particularmente por los componentes, debería haber preguntado todo en un solo post, mala mía, adjunto esquema de las otras entradas, estoy separando todo como dices, en una caja estanca de pvc coloque el arduino, protegido con una jaula de faraday, dentro de dicha caja tambien coloque el teclado matriarcal, el modulo lcd, pulsadores, potenciometro, y los modulos relay ssr pronto cuando los compre, por otro lado en un tablero metalico coloque las termicas, variador de frecuencia y driver para el motor PAP, este ultimo no se si colocarlo independientemente en otro lado, funciona con un transformador de 220v a 9v AC.

Bien si estas usando una caja aparte con el arduino, te recomiendo que hagas lo siguiente.

  • Coloca un condensador cerámico de 100nF entre la salida del potenciometro y GND. Esto hará que la salida sea un poco mas estable.

  • Coloca condensadores cerámicos de 100nF entre los terminales de los pulsadores. También recomiendo una buena rutina para eliminar el rebote (debounce) a la hora de leerlos.

  • El cable del display I2C intenta que sea lo mas corto posible.

  • Con el teclado matricial poco hay que hacer, salvo mantener los cables cortos.

  • @Tauro te recomendo cambiar de fuente. Las fuentes "enchufables" no son la mejor opción puesto que al final se descuelgan y te van a dar problemas. Puedes desmontar la fuente quitando la carcasa y en una placa de protototipos la pegas y la sueldas añadiendo terminales atornillables. Así de paso puedes añadir en la salida de 12V un condensador grande de 1000uF para arriba.

Esto en cuanto a entradas. En cuanto a salidas, si vas a usar relés de estado sólido dependiendo de la carga y del relé podras controlar directamente el motor monofásico y no te hará falta contactor.

El SSR no te valdrá para controlar el variador. Supongo que estas usando las entradas auxiliares de este para controlarlo, estas son generalmente de 24V y tendras que usar un relé normal.

En cuanto al control del motor PAP estoy pensando en dos cosas: primero que según el manual debería funcionar con una tensión entre 18 y 80 voltios en alterna o 24-110 en continua, no sé porque estás usando una de 9V. Lo segundo, es para evitar que los 5V del arduino salgan del armario y a lo mejor conviene hacer un arreglo con optoacopladores... Lo pensaré.

Hola @victorjam gracias por responder!, voy a probar añadiendo los condesadores tal cual me comentas, con respecto a la alimentacion del driver del motor PAP estaba equivocado, es un transformador 220v a 48v AC, el driver es un leadshine DMA830E, para el variador usare el rele mecanico, deberia comprar uno con optoacoplaor, el que poseo no tiene.

Otra de mis dudas es sobre el variador de frecuencia, seria correcto colocar el mismo dentro del tablero metalico junto a las termicas, disyuntor y transformador del driver PAP?, no entiendo mucho del tema, pero el campo magnetico que genera variador podria afectar significativamente estos dispositivos y arrastrar el problema a los componentes que alimentan?.

Más que el hecho de que genere un campo electromagnético que, como bien dices, colocando en un armario o retirado de cualquier otro componente del sistema se reduce bastante; creo que el problema de los variadores de frecuencia es la generación de armónicos. Este problema atañe mas a las fuentes de alimentación y pueden malograr su funcionamiento. Siempre usa una fuente de alimentación buena.

El variador necesita mucha ventilación, con lo cual el gabinete debe ser lo suficientemente grande y tener una buena entrada y salida de aire.

1 Like

Buenos dias @victorjam, gracias por tu ayuda, aplique todos los consejos dados y solucione el cuelgue del arduino, coloque puesta a tierra del variador y motor, asi como colocar el variador pegado al motor, tambien aisle el arduino en una caja aparte a 3m de todo lo de alta potencia, coloque un snubber a la salida del relay que controla el VDF y tambien el condensador de 1000uf en entrada de alimentacion del arduino, pero una vez solucionado eso me di cuenta que el comparador de voltaje optico lm393 que uso para contar las vueltas del motor monofasico de 6,7amp 3HP, cuenta de forma errada los pulsos, a veces contando pulsos de mas, lo que hace que el motor no se detenga nunca en la misma posicion, atribuyo esto al ruido, pero no se como aislar el sensor del mismo, este se encuentra justo debajo del eje del motor, obviamente expuesto obligadamente a las EMI, estaba leyendo sobre colocar un condesador de desacoplamiento, en los pines VCC y GND del comparador pero no se si sera suficiente.

adjunto el codigo de mi proyecto por si sirve de algo.

#include <LiquidCrystal_I2C.h>
#include <Keypad.h>

int contador = 1; // cuenta el nivel del menu en el que se esta
int decimal = 0;
int alto = 0;
int ancho;
int i = 0;
int alto_actual;
const byte ROWS = 4; //Cuatro Filas
const byte COLS = 4; //Cuatro Columnas
//// VARIABLES PROGRAMA  /////
const byte contactor_1 = 48;
const byte contactor_2 = 46;
int conta = 0;
int conta_hebras = 0;
int cant_hebras = 0; // CAMBIAR LUEGO
int largo_hebra = 0; // CAMBIAR LUEGO
int PUL= 44; 
int DIR= 42;
int EN= 40; //define Enable Pin
unsigned long tiempoViejo = millis();
bool buzzerStatus = true;
bool guillotinaStatus = true;
int saltar;
int estado_motor = 0;
int estado_guillotina = 0;
boolean funcionando = false;

char keys[ROWS][COLS] = {
    {'1', '2', '3', 'A'},
    {'4', '5', '6', 'B'},
    {'7', '8', '9', 'C'},
    {'*', '0', '#', 'D'}};
byte rowPins[ROWS] = {22, 24, 26, 28}; //Puntos de conexion del teclado al arduino FILAS
byte colPins[COLS] = {30, 32, 34, 36}; 
Keypad Teclado1 = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS); //Configura el teclado
LiquidCrystal_I2C lcd(0x27, 16, 2);                                       // dependiendo del fabricante del I2C el codigo 0x27 cambiar a
// 0x3F , 0x20 , 0x38 ,
////////////////////////////////// Void Setup() ///////////
void setup()
{
  Serial.begin(9600);
  pinMode (10, OUTPUT);
  pinMode (PUL, OUTPUT);
  pinMode (DIR, OUTPUT);
  pinMode(contactor_1, OUTPUT); ///RELE CONTACTOR 1
  pinMode(contactor_2, OUTPUT); // RELE CONTACTOR 2
  pinMode(38, INPUT);           // SENSOR
  pinMode (52, INPUT_PULLUP);   // PULSADOR MOTOR PRINCIPAL
  pinMode (50, INPUT_PULLUP);   // PULSADOR MOTOR GUILLOTINA

  

  lcd.init();
  lcd.backlight();

  intro_0(); // muestra el intro de bienvenida
  mostrar_menu(1);
}
////////////////////////// Void loop() ///////////////////////
void loop()
{
/// ACCIONAMIENTO MANUAL MOTOR PRINCIPAL ///
 estado_motor = digitalRead(52);
 estado_guillotina = digitalRead(50);

  if (estado_motor == 0 and funcionando == false)
      {
      digitalWrite(contactor_1, HIGH);
      }else {
      digitalWrite(contactor_1, LOW);
      }
  if (estado_guillotina == 0 and funcionando == false)
      {
      digitalWrite(contactor_2, HIGH);
      delay (2000);
      }else {
      digitalWrite(contactor_2, LOW);
      }
///////////////////////////////////////////
 
 char key = Teclado1.getKey();  

  if (key)
  {
    if (key == '#')
    {
      if (contador != 0 or contador != 4)
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW);
        mod_contador(1);
        mostrar_menu(contador);
        i = 0;
        alto = 0;
      }
    }
    else if (key == '*')
    {
      if (contador != 0 or contador != 4)
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW);
        mod_contador(-1);
        mostrar_menu(contador);
        i = 0;
        alto = 0;
        alto_actual = 0;
      }
    }
    else if (contador == 1)
    {
      if (key == 'A')
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW); 
        ancho = 5;
        menu_1(5);
      }
      else if (key == 'B')
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW);
        ancho = 10;
        menu_1(10);
      }
      

      ///////////////////INGRESO MEDIDA MENU 2 ////////////////////////////
    }
    else if (contador == 2)
    {
    if (key != 'A' and key != 'B' and key != 'C' and key != 'D')
    {
      if (i <= 2)
      {
        if (key == '1')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);          
          decimal = 1;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '2')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 2;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '3')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 3;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '4')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 4;
          alto_actual = alto = alto * 10 + decimal;
          ;
          i++;
          menu_2();
        }
        else if (key == '5')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 5;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '6')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 6;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '7')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 7;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '8')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 8;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '9')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 9;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }
        else if (key == '0')
        {
          digitalWrite(10,HIGH);
          delay (100);
          digitalWrite(10,LOW);
          decimal = 0;
          alto_actual = alto = alto * 10 + decimal;
          i++;
          menu_2();
        }

        if ((contador == 2) and (alto_actual > 200))
        {
          alto_actual = 0;
          advertencia();
        } //// advertencia/////

        if ((contador == 2) and (i >= 3))
        {
          i = 0;
          alto = 0;
        }

      }
     } 
    }
    else if (contador == 3)
    {

      if (key == 'A')
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW);
        programaA();
      }
      if (key == 'B')
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW);
        programaB();
      }
      if (key == 'C')
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW);
        programaC();
      }
      if (key == 'D')
      {
        digitalWrite(10,HIGH);
        delay (100);
        digitalWrite(10,LOW);
        programaD();
      }
    }
  }
}
///////// Fin del void loop(), inician las Funciones///////////////

void mod_contador(int c)
{
  contador = contador + c;
  if (contador == 0)
  {
    contador = 1;
  }
  else if (contador == 4)
  {
    contador = 3;
  }
}
/////////////////////Intro_0 //////////////////////////////
void intro_0()
{
  lcd.clear();         // Borra el LCD
  lcd.setCursor(3, 0); // Se posiciona en la Columna 3, Fila 0
  lcd.print("BIENVENIDO");
  lcd.setCursor(2, 1);
  lcd.print("INICIALIZANDO");
  delay(1000); // espera 4 segundos mostrando el intro
  lcd.clear();
}

/////////////////////Menu_1 //////////////////////////////////

void mostrar_menu(int c)
{

  if (c == 1)
  {
    menu_1(0);
  }
  else if (c == 2)
  {
    menu_2();
  }
  else if (c == 3)
  {
    menu_3();
  }
}
void menu_1(int ancho_actual)
{

  lcd.clear();
  ancho = ancho_actual;
  lcd.setCursor(0, 0);
  lcd.print("Largo Rollo:");
  lcd.setCursor(13, 0);
  lcd.print(ancho_actual);
  lcd.setCursor(15, 0);
  lcd.print("M");
  lcd.setCursor(0, 1);
  lcd.print("A- 5M B- 10M ->#");
}

/////////////////////Menu_2 //////////////////////////////////
void menu_2()
{

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Medida:");
  lcd.setCursor(7, 0);
  lcd.print(alto);
  lcd.setCursor(11, 0);
  lcd.print("*");
  lcd.setCursor(13, 0);
  lcd.print(ancho);
  lcd.setCursor(15, 0);
  lcd.print("m");
  lcd.setCursor(0, 1);
  lcd.print("* <--      --> #");
}

/////////////////////Menu_3 //////////////////////////////////
void menu_3()
{

  lcd.clear();
  lcd.setCursor(1, 0);
  lcd.print("A-2,5P");
  lcd.setCursor(9, 0);
  lcd.print("B-NN");
  lcd.setCursor(1, 1);
  lcd.print("C-NN");
  lcd.setCursor(9, 1);
  lcd.print("D-NN");
}

/////////////////////Programa A //////////////////////////////////
void programaA()
{
 int porcentaje = 0;
  // CONVERTIDOR DE METROS DE LARGO A HEBRAS //
  
  if (ancho == 10) {
  cant_hebras = 90;
  } else if (ancho == 5) {
   cant_hebras = 45;
  }
 // CONVERTIOR DE CM A PULSOS //
  
  largo_hebra = alto_actual * 30 / 100;

      
  if (ancho != 0 and alto_actual != 0)
  {

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("....INICIANDO...");
    lcd.setCursor(0, 1);
    lcd.print(".....ESPERE.....");
    delay(1000);

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("HEBRAS:");
     
    lcd.setCursor(15, 0);
    lcd.print("%");

    lcd.setCursor(0, 1);
    lcd.print("PULSOS:");

    lcd.setCursor(10, 1);
    lcd.print("PARO-*");
   
    funcionando = true;
    boolean escanear = true;
    boolean salir = true;
    escanear = true;
    
    
    while (conta_hebras <= cant_hebras)
    {
      // CALCULO PORCENTAJE PROGRESO //
      
      if (cant_hebras == 90){
      porcentaje = map(conta_hebras, 0, 90, 0, 100);
      }
      if (cant_hebras == 45){
      porcentaje = map(conta_hebras, 0, 45, 0, 100);
      }
      
      lcd.setCursor(12, 0);
      lcd.print(porcentaje);
      //------------------------------//
      
      char key = Teclado1.getKey();
      
                         
              delay(500);
              digitalWrite(contactor_1, HIGH); //ABRE CONTACTOR MOTOR PRINCIPAL
        
              while (escanear)
              {
              
               char key = Teclado1.getKey();

     if (key != '*') {
                                                 
                if (digitalRead(38) == HIGH)
                {
                  conta++;
                  delay(100);
                                  
                  lcd.setCursor(7, 1);
                  lcd.print(conta);
        
                  if (conta == largo_hebra)
                  {
                    digitalWrite(contactor_1, LOW); //CIERRA CONTACTOR MOTOR PRINCIPAL
                    escanear = false;
                  }
                }
              
    }else if (key == '*'){
  
    escanear = false;
    digitalWrite(contactor_1, LOW);
    conta_hebras = cant_hebras;
    alto_actual = 0;
    goto final;
            
    }        
              }
                  
              digitalWrite(contactor_2, HIGH); //ENCIENDE GUILLOTINA
              delay(2000);
              digitalWrite(contactor_2, LOW);
              
              //MOTOR PASO A PASO
              digitalWrite(DIR,HIGH);
              for (int i=0; i<600; i++) // MODIFICAR SEGUN CORRESPONDA
              
              {
                digitalWrite(PUL,HIGH);
                delayMicroseconds(400);
                digitalWrite(PUL,LOW);
                delayMicroseconds(400);
              }
        
              conta_hebras++; // cuenta hebras
              conta = 0;      // reinicia pulsos
              lcd.setCursor(7, 0);
              lcd.print(conta_hebras);
              escanear = true;    
              
    }
     final:       
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("..FINALIZADO..");
          lcd.setCursor(2, 1);
          lcd.print("* <- REINICIAR");
  
                                                      
   while (salir) {

              char key = Teclado1.getKey(); 
                        
                    if (key == '*')
                    {                 
                     digitalWrite(10,LOW);
                     salir = false;                     
                    }                                   
                          digitalWrite (10, buzzerStatus);
                          
                          if(millis()-tiempoViejo >= 1000){
                            tiempoViejo=millis();
                            buzzerStatus = !buzzerStatus;
                          }                                        
  }                         
                                                       
    digitalWrite(10,LOW); 
    funcionando = false;
    conta = 0;
    conta_hebras = 0;
    contador = 1;
    mostrar_menu(1);
  }
  else if ((ancho == 0 and alto_actual == 0) or (ancho != 0 and alto_actual == 0) or (ancho == 0 and alto_actual != 0))
  {
    advertencia_2();
  }

}

//////////FUTUROS PROGRAMAS//////////
void programaB()
{
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print("NO DISPONIBLE");
  delay(1500);
  contador = 3;
  menu_3();
}
void programaC()
{
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print("NO DISPONIBLE");
  delay(1500);
  contador = 3;
  menu_3();
}
void programaD()
{
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print("NO DISPONIBLE");
  delay(1500);
  contador = 3;
  menu_3();
}

//////////////// ADVERTENCIA INGRESO MEDIDA + 2M////////////////////////////
void advertencia()
{

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("....ATENCION....");
  lcd.setCursor(0, 1);
  lcd.print("El limite es 2M");
  delay(1500);
  alto = 0;
  contador = 2;
  menu_2();
}
//////////////// ADVERTENCIA INGRESO MEDIDA SOLO CEROS////////////////////////////
void advertencia_2()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(".....ERROR......");
  lcd.setCursor(0, 1);
  lcd.print("Medida:    *");
  lcd.setCursor(7, 1);
  lcd.print(alto_actual);
  lcd.setCursor(13, 1);
  lcd.print(ancho);
  lcd.setCursor(15, 1);
  lcd.print("m");
  delay(1500);  
  alto_actual = 0;
  alto = 0;
  contador = 2;
  menu_2();
}

Hi,
Mi sugerencia es de que leas el voltaje en los pines +positivo y - negativo. del op-amp. cuando el motor esta corriendo. Dependiendo de los voltajes puedes adjuntar con la resistencia variable de 1K donde dispara la senal del comparador del op-amp.

De hecho, viendo el esquema del circuito, colocaria dos conensadores: entre VCC-GND y otro entre OUT-GND.

Puedes ver como aqui.

De todas formas al ver el código veo que hay mucho delay... Y posiblemente algo este fallando en algún sitio.

Ve a documentación, lee como usar millis() en lugar de delay().
Aprende a trabajar sin delay().
No digo que eso solucione los problemas pero te acercará a la solución.
Se puede hacer muchas cosas con los rebotes por ejemplo si no tienes 2 seg en que el micro se cruza de brazos.
Ejemplo: podrias usar una rutina anti rebote.. algo que confirme el estado en 0 o 1 del sensor optico. No son soluciones elegantes pero si careces de osciloscopio y nopuedes ver que ocurre en el captor bajo el eje.. tienes que trabajar con las consecuencias de la interferencia que tienes.
Eventualmente lo resolverás.

No he leído todo el hilo. Has usado cable con malla para capturar los pulsos?

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.