Creando un tester de cables de red — Federico Torres’ Blog

En el ámbito de las redes informáticas, contar con herramientas que permitan validar rápidamente la correcta conexión de un cable RJ45 es muy importante. Por eso decidí desarrollar un tester de cables casero, como una solución práctica y económica para detectar fallas al armar cables RJ45 según el estándar T-568-B y también probar cableado existente.

Objetivo

El objetivo de este proyecto fue construir un dispositivo capaz de comprobar la correcta correspondencia de los pines en un cable de red RJ45 según el estándar T-568-B para directo y cruzado.

Materiales y herramientas

Para desarrollar este proyecto, utilicé los siguientes materiales:

Arduino Nano,
Filamento para impresora 3D gris,
Display LCD 16x4,
Módulo adaptador de LCD a I²C,
Cable USB mini,
Cables DuPont macho,
Fichas RJ45 (x2),
Adaptador union/empalme RJ45 (x2),
Cables de red para probar,

y las siguientes herramientas

Pinza crimpeadora,
Alicates,
Soldador de estaño,
Impresora 3D,
Una computadora con Arduino IDE.

Diseño y funcionamiento

Componentes

Básicamente, se verifica si el cableado de un conector RJ45 cumple con el estándar de conexión adecuado (por ejemplo T-568-A o T-568-B) mediante una comparación secuencial de continuidad entre los pares de pines en los extremos. El resultado de ésto se muestra en una pantalla LCD para los modos Crossover (Cruzado) y Straight-Through (Directo).

Para realizar éste procesamiento se utilizó un Arduino Nano, que permite realizar las operaciones necesarias ocupando poco espacio. Además, se lo programó en el lenguaje Arduino.

En cuanto a los componentes electrónicos, el LCD posee un módulo que permite simplificar el cableado para que se pueda comunicar el Arduino Nano sencillamente con I²C usando una librería específica para este dispositivo.

Los cables a testear se conectan a 2 extensores RJ45 en la parte exterior del dispositivo. Por dentro, hay dos fichas RJ45 que están permanentemente conectadas a cada extensor, cuyos cables están soldados sobre el Arduino Nano.

Por último, se soldó un cable usb que permite brindarle tensión eléctrica al microcontrolador. Además, se imprimió una carcasa específica para las necesidades de este proyecto usando una impresora 3D.

Código

Los pines de entrada del arduino están configurados como INPUT_PULLUP lo que permite que no sea necesario usar resistencias pulldown a expensas de tomar los 0 como valor alto y los 1 como valor bajo.

Al principio del código declaro los pines que voy a utilizar y creo el objeto lcd.

#define PinC1_1 8
#define PinC1_2 17
#define PinC1_3 2
...

#define PinC2_1 16
#define PinC2_2 9
#define PinC2_3 10
...

LiquidCrystal_I2C lcd(0x27,20,4);

Genero dos listas de pines. Una que corresponde a los pines de salida y otra que corresponde a los pines de entrada.

const int CO[] = {PinC1_1, PinC1_2, PinC1_3, PinC1_4, PinC1_5, PinC1_6, PinC1_7, PinC1_8};
const int CI[] = {PinC2_1, PinC2_2, PinC2_3, PinC2_4, PinC2_5, PinC2_6, PinC2_7, PinC2_8};

Además genero las matrices que me indican la correspondencia entre pines.

const int StraightThrough[][2] = {
  {PinC1_1, PinC2_1},
  {PinC1_2, PinC2_2},
  {PinC1_3, PinC2_3},
  {PinC1_4, PinC2_4},
  {PinC1_5, PinC2_5},
  {PinC1_6, PinC2_6},
  {PinC1_7, PinC2_7},
  {PinC1_8, PinC2_8}
};

const int CrossOver[][2] = {
  {PinC1_1, PinC2_3},
  {PinC1_2, PinC2_6},
  {PinC1_3, PinC2_1},
  {PinC1_4, PinC2_7},
  {PinC1_5, PinC2_8},
  {PinC1_6, PinC2_2},
  {PinC1_7, PinC2_4},
  {PinC1_8, PinC2_5}
};

He creado varias funciones que me permiten encapsular comportamientos del programa que son muy importantes:

Setear todos los pines seleccionados a nivel alto (0)
Setear todos los pines seleccionados a nivel bajo (1)
Setear todos los pines seleccionados como entrada
Setear todos los pines seleccionados como salida

Una función muy importante es detectCable(), ya que me permite saber si el usuario ha conectado un cable de red en dispositivo. Retornará un bool dependiendo de lo que se haya detectado.

bool detectCable(){
  setAllHigh(CO);
  for(int i=0; i < 8; i++){
    if (digitalRead(CI[i]) == HIGH_PullUp){
      return true;
    }
    delay(10);
  }
  return false;
}

La función que tal vez sea la más importante aquí es comparePins(). Se encarga de detectar la correspondencia de pines dependiendo de la matriz que se le pase como parámetro. Dependiendo de lo que encuentre mostrá | si es válida la conexión y X si no lo es.

void comparePins(int S[][2]){
  // set every output pin to low
  setAllLow(CO);

  // loop parameter
  for (int i=0; i < 8; i++){

    // set pin to 1
    setBitIO(S[i][0], HIGH_PullUp);

    if (digitalRead(S[i][1]) == HIGH_PullUp){
      // link is correct

      lcd.print("| ");
      delay(50);
    } else{
      // link is incorrect

      Serial.print(S[i][0]);
      Serial.print("-->");
      Serial.println(S[i][1]);
      lcd.print("X ");
      delay(50);
    }

    // set pin back to 0
    setBitIO(S[i][0], LOW_PullUp);
  }
}

En el void setup() simplemente inicializamos el display LCD y seteamos ciertos pines como salida y otros como entrada.

Por último, en el void loop(), llamaremos a detectCable() en cada recursión. Si retorna verdadero (se detectó un cable de red), entonces se imprime la grilla en el display y se comienzan a comparar los pines. Si retorna falso, (no se detectó un cable de red) se muestra una pantalla de carga, esperando a que el usuario enchufe el cable. En cualquiera de los 2 casos, se esperan 10 segundos y se vuelve al principio del void loop(), que repite lo dicho anteriormente hasta que se apague el dispositivo.

El programa se probó en un mini-protoboard, con cables DuPont, para luego ser soldado con estaño de manera permanente. El código fuente se encuentra en mi github por si deseas revisarlo.

Resultados

El proyecto ya terminado se probó con cables T-568-B directo y cruzado, y se llegó a los resultados esperados. También se testeó el proyecto con cables armados de manera incorrecta como ejemplo y los resultados también fueron los que se esperaban.

El gabinete en el que están los componentes tuvo que ser modificado manualmente posteriormente a la impresión debido a que ciertas medidas no salieron como deberían y el material se dobló más de lo esperado. Realicé varios modelos impresos con menor densidad para ir probando la disposición de los componentes electrónicos. Cabe aclarar que muchas veces la soldadura de los cables se cortaba y hacía muy difícil que no haya contacto entre pines en el microcontrolador.

A lo largo de la realización del proyecto surgieron distintos problemas. Por ejemplo, al no haber conectado ningún cable, las entradas indicaban valores aleatorios. La solución que encontré a ésto fue soldar resistencias pulldown a masa o usar la resistencia pullup integrada en la placa Arduino Nano. Decidí hacer lo último, ya que me permitió ahorrar tiempo, recursos y espacio en el gabinete. Después, se encontró que algunos pines de entrada no mostraban los resultados esperados cuando se los configuraba como INPUT_PULLUP pero sí cuando se los configuraba como INPUT. La solución a ésto fue cambiar esos pines a OUTPUT y el otro pin relacionado con éste a INPUT_PULLUP, a través de los DEFINE en la parte superior del programa.

Conclusión y aprendizajes

Éste proyecto me permite contar con una herramienta muy útil en el ámbito de las redes informáticas, ya que es utilizado cada vez que se desea armar o probar un cable de red nuevo. Aprendí sobre los estados de alta impedancia en pines, cuándo utilizar una resistencia pullup y cuando usar una resistencia pulldown, además de mejorar mis conocimientos sobre los estándares T-568-A y T-568-B directo y cruzados, que antes no conocía.

A futuro se puede mejorar del proyecto:

Que pueda poseer una pila, para no depender de una fuente de alimentación;
Que tenga botón de encendido y apagado, para complementarse con el punto anterior;
Una alerta de cortocircuito, para saber si un cable está cortado.