Conectar pantalla LCD 16x2 a Raspberry Pi

Aunque el proyecto de la radio está muy olvidado, ahora que tengo algo de tiempo he investigado si en lugar de utilizar un Arduino de intermediario (como hacía hasta ahora) era posible conectar una pantalla LCD directamente al Raspberry Pi utilizando los puertos GPIO (General Purpose Input Output) que incluye. La respuesta es que sí que se puede, y que no es demasiado complicado. Así que, cuando continúe con el proyecto de la radio, posiblemente me decida a descartar el uso del Arduino y conectar todo al Raspberry. Para muestra, un botón:

En mi caso, he usado una pantalla simple 16x2 compatible con el controlador HDD44780. Básicamente, cualquier pantalla económica de 16x2 que encuentres en eBay o similares será compatible con este controlador. Algunas, más caras, tienen una interfaz I2C o SPI que nos permiten entre otras cosas utilizar menos cables. La interfaz de dicha pantalla es paralela, con 4 cables para datos y, además, tiene algunos conectores adicionales para la luz, el contraste, el modo de funcionamiento, etc.

Para mostrar el texto en la pantalla utilizaremos un pequeño programa en Python (una vez hayamos instalado las librerías necesarias para poder controlar desde Python los puertos GPIO del Raspberry). Pero empecemos por el principio:

1. Realizando las conexiones

Además de los puertos que solemos usar en el Raspberry (USBs, Ethernet, HDMI, Audio…), tenemos disponibles otros puertos para conexiones de más bajo nivel. Entre otros tenemos un puerto serie, UART, I2C, SPI y 13 puertos GPIO que se pueden programar para adaptarse a nuestras necesidades. Para más información se puede consultar este enlace. Todos estos puertos están situados en los pines de la esquina del Raspberry:

Y el diagrama de dichos puertos es el siguiente:



En cuanto a las pantallas 16x2 (aunque también hay disponibles otros tamaños como 20x4), todas tienen 16 pines cuyo diagrama es el siguiente:



Los pines de datos son los DBX, aunque en la práctica se suelen utilizar sólo DB4-DB7. Para más información sobre estas pantallas se puede consultar este enlace, donde además se puede descargar el datasheet completo de las mismas.

Siendo el Pin 1 de la pantalla situado más a la izquierda (GND), las conexiones que hay que realizar entre el Raspberry y la pantalla son las siguientes (es conveniente ayudarse de una protoboard):

• Pin 1 de la pantalla (GND) a tierra.
• Pin 2 de la pantalla (VCC) a +5V.
• Pin 3 de la pantalla (VEE) a tierra.
• Pin 4 de la pantalla (RS) a GPIO 25.
• Pin 5 de la pantalla (RW) a tierra.
• Pin 6 de la pantalla (EN) a GPIO 24
• Pin 7, 8, 9 y 10 de la pantalla desconectados.
• Pin 11 de la pantalla (D4) a GPIO 23
• Pin 12 de la pantalla (D5) a GPIO 17
• Pin 13 de la pantalla (D6) a GPIO 21
• Pin 14 de la pantalla (D7) a GPIO 22
• Pin 15 de la pantalla (LED+) a 5V.
• Pin 16 de la pantalla (LED-) a tierra.
  

Aunque con estas conexiones tenemos suficiente, podemos conectar un potenciómetro al pin 3 para poder regular el contraste de la pantalla (si lo conectamos a tierra, estará al máximo). Del mismo modo, podemos conectar un potenciómetro a LED+ para reducir el brillo de la misma (o incluso conectarlo a 3V3 Power, de proporciona 3.3V en lugar de los 5V).

El diagrama de las conexiones sería el siguiente:

Este diagrama (y gran parte de este tutorial está basado en el de la web de Adafruit).

2. Instalando los paquetes necesarios

El segundo paso es instalar en nuestra distribución (yo estoy usando Raspbian) los paquetes necesarios para poder ejecutar nuestro script. En este paso será necesaria una conexión a Internet en el Raspberry.

Comenzaremos instalando los paquetes de desarrollo de Python, Python PIP (una especie de Synaptic pero para las librerías de Python), las Setup Tools para poder instalar easy_install y git para descargar más adelante los códigos de ejemplo de la página de Adafruit:

sudo apt-get install python-dev python-setuptools python-pip git

A continuación actualizaremos la herramienta distribute (parte de setuptools), que nos ayudará a descargar la librería GPIO:

sudo easy_install -U distribute

Una vez hecho esto, por fin podremos descargar la librería GPIO para Python:

sudo pip install rpi.gpio

 

3. Descargando códigos de ejemplo

Adafruit mantiene un repositorio Git con diversos códigos de ejemplo para el Raspberry. La forma más sencilla de descargarlos a nuestro sistema es clonar el repositorio. Como ya instalamos git en el paso anterior, basta con introducir:

git clone git://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git

Tras unos instantes, se habrá creado en el directorio actual una carpeta llamada Adafruit-Raspberry-Pi-Python-Code con multitud de subcarpetas. A nosotros nos interesa en concreto la subcarpeta Adafruit_CharLCD:

cd Adafruit-Raspberry-Pi-Python-Code
cd Adafruit_CharLCD

4. Modificando el código de ejemplo (sólo Raspberry Pi Rev. 2)

El código de ejemplo que vamos a utilizar es Adafruit_LCD.py. Si tenemos un Raspberry Rev. 1 (las primeras Raspberry, que no tenían agujeros para tornillos en la placa y sólo tenían 256MB de RAM en el modelo B) el código funcionará perfectamente. Si por el contrario tenemos un Raspberry Rev. 2 (con agujeros para tornillos y 512MB de RAM en el modelo B), hay que realizar una pequeña modificación en el código. Para ello, podemos abrirlo con nano:

nano Adafruit_CharLCD.py 

Y en la línea donde pone:

def __init__(self, pin_rs=25, pin_e=24, pins_db=[23, 17, 21, 22], GPIO = None

Reemplazar el 21 por un 27 (esto es debido a un cambio en los puertos del modelo 2 del Raspberry. Para guardar el archivo modificado pulsamos Ctrl+O y salimos con Ctrl+X.

 

5. Probando todo

Sólo nos queda dar permisos de ejecución al programa y ejecutarlo con:

chmod +x Adafruit_CharLCD.py
sudo ./Adafruit_CharLCD.py

Si todo ha ido bien, deberíamos ver algo parecido a lo siguiente:

En caso de no obtener el texto, lo más probable es que no hayamos hecho correctamente las conexiones entre el Raspberry y la pantalla, por lo que lo mejor es repasarlas para buscar posibles errores. También puede que nos hayamos saltado el paso 4 teniendo un Raspberry Rev. 2. Para asegurarte de tu versión de Raspberry, mira la siguiente imagen:

El Raspberry de la izquierda es la revisión 1 y el de la derecha es la revisión 2. Se distinguen fácilmente por los agujeros para tornillos marcados con las flechas rojas.

 

6. Mostrando fecha, hora y dirección IP interna

Si queremos mostrar algo parecido a lo que se puede ver en la primera imagen de esta entrada, basta con ejecutar el otro ejemplo del directorio:

chmod +x ./Adafruit_CharLCD_IPclock_example.py
sudo ./Adafruit_CharLCD_IPclock_example.py

Unir dos ficheros PDF en Linux

Podemos unir fácilmente dos archivos PDF usando pdftk. No suele estar instalado por defecto, por lo que los pasos serán:

1. Instalamos pdftk. En Ubuntu lo haríamos con:
sudo apt-get install pdftk
2. Concatenamos los dos (o más archivos) con:
pdftk <archivo1.pdf> <archivo2.pdf> cat output <archivofinal.pdf>

Mejorar renderizado de fuentes en Netbeans

Al hilo de la anterior entrada sobre el renderizado de fuentes en Linux, seguramente nos haya pasado que en algunos programas como Netbeans o JDownloader los textos se vean peor que en el resto de aplicaciones del sistema operativo. La razón parece ser que dichas aplicaciones están programadas usando Swing (la biblioteca gráfica JFC de Java), la cual utiliza su propio motor de renderizado, y que en muchas ocasiones se traduce en que en Linux las fuentes se ven bastante mal.

Afortunadamente, los mismos programadores de Infinality, que vimos en la entrada anterior, se han encargado de parchear OpenJDK para conseguir un renderizado de fuentes decente con aplicaciones que usen Swing. Según dicen en su repositorio en Launchpad, sólo mantienen paquetes para la distribución de Ubuntu más reciente (a fecha de hoy es la 13.04) y la LTS que haya actualmente activa (a fecha de hoy es la 12.04). Por suerte estoy usando Ubuntu 13.04, por lo que instalar OpenJDK parcheado es tan sencillo como:

1. Añadir el ppa:

$ sudo add-apt-repository ppa:no1wantdthisname/openjdk-fontfix

2. Actualizar paquetes:

$ sudo apt-get update

3. Instalar OpenJDK:

$ sudo apt-get install openjdk-7-jdk

El resultado es prácticamente el de una aplicación que use el renderizador nativo:

Mejorar renderizado de fuentes en Linux

Una de las cosas que noté en su día al empezar a usar Linux es que los textos "se veían mejor" en Windows. La solución que se podía encontrar por Internet era instalar las fuentes de Windows (msttcorefonts), pero ese no era el problema: las fuentes seguían viéndose menos nítidas que en Windows, al menos para mi gusto.

Años más tarde, y por un tema completamente diferente, me he enterado que el problema es el renderizador que utiliza Linux para el suavizado de las fuentes (el equivalente al ClearType de Microsoft). El renderizador se encarga entre otras cosas del suavizado de las fuentes para evitar que se vean los bordes de los caracteres. En esta imagen, sacada de este blog, se puede ver más claramente:

La imagen de la izquierda es una fuente normal, dibujada en la pantalla sin ningún tipo de suavizado. Es desde luego la forma más nítida de ver el texto, pero tiene el inconveniente de que se notan claramente los bordes dentados. Hay fuentes que se diseñan teniendo en cuenta esto, especialmente para programación, pero cada vez son menos usadas.

En la imagen central puede verse la misma fuente con un antialias estándar. También se denomina "suavizado con escala de grises". En este caso, en lugar de utilizar sólo el color base (en este caso el negro) tenemos disponibles 256 tonos de gris que, como vemos, se utilizan para suavizar el contorno de la fuente. El resultado, aunque algo menos nítido que el anterior, es mucho más agradable a la vista.

Por último, en la imagen de la derecha, tenemos el "suavizado de subpíxel" que mejora el suavizado de escala de grises anterior. Nuestro problema es que, debido al tamaño de los píxeles, los tonos de gris intermedios hacen que la fuente pierda nitidez al usar el método anterior. El suavizado de subpíxel intenta conseguir los resultados del suavizado con escala de grises pero perdiendo la mínima nitidez posible. Para ello se basa en una idea muy ingeniosa: cada píxel de un monitor está compuesto de tres subpíxeles con los colores primarios (RGB) cuya intensidad se regula para obtener el color final de ese píxel en concreto. Un píxel ampliado es muy similar al cuadrado de tres colores que puede verse en la esquina superior derecha de la imagen anterior.

La idea básica es que si queremos aumentar un poco el grosor de la fuente por la derecha, lo que haremos es usar un tono de rojo de modo que el subpíxel verde y el azul estén "apagados" y el rojo esté más o menos "encendido". Del mismo modo, si queremos aumentar un poco el grosor por la derecha, regularemos el subpíxel azul y apagaremos el verde y el rojo. Si queremos aumentar un poco más el grosor buscaremos un tono que encienda los subpíxeles verde y rojo o verde y azul según el caso, y de este modo tenemos tres veces más resolución horizontal con la misma pantalla.

En este concepto se basa Cleartype para Windows y el renderizador de fuentes de Linux en su opción por defecto. Adicionalmente, algunas distribuciones como Ubuntu han mejorado el renderizador para obtener textos más nítidos.

El problema es que hay distribuciones, como Debian, en las que las fuentes no se ven tan nítidas. Afortunadamente existe un proyecto llamado Infinality que introduce unos parches que mejoran el renderizado de los textos. De hecho, permiten incluso adoptar renderizados similares a los que se usan en MacOS, Ubuntu o Windows entre otros.

Las diferencias son notorias, como se puede ver en la imagen siguiente sacada de Webupd8:

Aunque en la imagen ya se nota suficiente, es cuando lo tienes instalado cuando te das cuenta de que todos los textos se ven mejor. Si queremos instalarlo, en el enlace anterior nos explican cómo, pero a grosso modo, en Ubuntu:

1. Añadimos el PPA correspondiente:
sudo add-apt-repository ppa:no1wantdthisname/ppa

2. Actualizamos los repositorios:
sudo apt-get update 
sudo apt-get upgrade

3. Instalamos Infinality 
sudo apt-get install fontconfig-infinality

4. Lo configuramos
sudo bash /etc/fonts/infinality/infctl.sh setstyle

Al ejecutar esta orden podremos elegir el estilo que queremos utilizar para el renderizado. Yo suelo escoger el de Ubuntu o el de Linux.


5. Reiniciamos o cerramos sesión para ver los cambios
Para instalar Infinality en el resto de distribuciones o para configuraciones más avanzadas, lo mejor es leerse el post original de Webupd8 (en inglés).
 

Creando túneles SSH con Putty

Para transferir archivos con un servidor del trabajo, me resulta muy cómodo usar WinSCP. El problema surge cuando me conecto desde mi piso, y he de entrar primero al servidor general de SSH y, una vez ahí, acceder al servidor en cuestión mediante su IP interna. En este caso no podía usar WinSCP y tenía que transferir los ficheros manualmente con scp… hasta ahora.

¿La solución? Accedemos al servidor en cuestión con un cliente SSH como Putty y establecemos un túnel SSH entre el servidor y nuestro PC. A continuación conectamos WinSCP al “lado” del túnel que se encuentra en nuestro PC, y de forma transparente la información llegará al otro “lado”, es decir, al servidor.

Para que se entienda mejor, he hecho un pequeño esquema:

Tenemos por un lado el PC de mi casa. Desde él, puedo hacer un SSH al servidor SSH a través de Internet, pero no al servidor destino, ya que éste no tiene su IP ni su puerto SSH conectado a Internet, sino a la red interna. Lo que queremos conseguir es algo parecido a la flecha verde de arriba: conectarnos al servidor destino de manera que el resto de aplicaciones crean que se trata de una conexión directa.

Hacer esto con Putty es muy sencillo. Comenzamos abriéndo Putty y estableciendo los datos generales de la conexión:

En “Host Name” he puesto la dirección del servidor SSH, desde el cual tengo que acceder a servidor destino. Podemos cambiar también la codificación de caracteres (en Window>Translation) y poner el nombre de usuario por defecto en Connection>Data. Pero vayamos a la parte interesante:

En Connection>SSH>Tunnels podemos establecer nuestro túnel. Para ello, en Source Port pondremos nuestro “lado” del túnel, es decir, el puerto de nuestro PC que vamos a conectar con el servidor destino. En Destination pondremos el otro “lado” del túnel, es decir, la dirección y el puerto del servidor destino una vez que hemos entrado en el servidor SSH. Por último pulsamos en Add y podemos ver que se ha añadido una línea como la que he tachado parcialmente en azul. Básicamente esto dice: “Cuando nos conectemos al puerto 2222 de nuestro PC, en realidad accederemos al servidor destino Y:22, que se encuentra dentro de la conexión SSH que hemos establecido previamente con el servidor SSH X:22. Si abrimos ahora la conexión, podemos comprobar cómo funciona perfectamente:

Como vemos, cuando accedemos al puerto 2222 de nuestra máquina, vemos el SSH del servidor destino. Ahora que vemos que el túnel funciona, sólo queda conectarnos con WinSCP directamente a localhost:2222, y podremos acceder directamente al servidor destino gracias al túnel SSH.

[Libro] The Architecture of Open Source Applications

Los arquitectos observan miles de edificios durante su entrenamiento y estudian las críticas a esos edificios que han hecho los maestros. A diferencia de esto, la mayoría de los desarrolladores de software sólo llegan a conocer bien unos pocos grandes programas –normalmente los que escriben ellos mismos- y nunca estudian grandes programas que se han creado a lo largo de la historia. Como resultado, muchos acaban repitiendo los errores de los demás en lugar de partir de sus éxitos.

Nuestro objetivo es cambiar esto. En estos dos libros, los autores de 48 aplicaciones de software libre explican cómo está estructurado este software y por qué. ¿Cuáles son los grandes componentes de cada programa? ¿Cómo interaccionan? ¿Qué aprendieron sus creadores durante el desarrollo? Respondiendo a estas preguntas, los colaboradores de estos libros proporcionan una visión única de su forma de pensar.

Si eres un desarrollador junior y quieres aprender cómo piensan otros colegas con más experiencia, estos libros pueden ser el lugar desde el que empezar. Si eres un desarrollador intermedio o senior y quieres ver cómo otros compañeros han resuelto complejos problemas de diseño, estos libros pueden serte de ayuda también.

El texto de arriba es la introducción a estos dos volúmenes que viene (en inglés) en su web oficial: http://www.aosabook.org/en/ Lo poco que llevo leído (uno de los artículos sobre el juego Battle of Westnoth) me ha gustado bastante. En él, en pocas páginas, dos de sus desarrolladores explican cómo está diseñado el juego, cómo y porqué diseñaron su arquitectura, y varias decisiones de diseño explicadas. Me resulta especialmente interesante que sean los propios desarrolladores los que den su visión sobre el programa, y den su opinión sobre sus puntos fuertes y sus carencias, y te expliquen con detalle algunos aspectos del mismo. Además de este artículo, también aparecen entre otros programas como Eclipse, CMake, Mercurial, SendMail, Audacity, Moodle, Git o GDB.

Lo mejor es que los libros se pueden leer gratuitamente desde la página oficial, eso sí, sólo la versión online HTML. Si los queremos en formato eBook (Kindle/ePub) o en formato físico podemos comprarlos directamente de la web, o a través de Amazon o Lulu, y donarán gran parte de las ganancias a Amnistía Internacional.

[Proyecto] Cliente torrent con Transmission y Raspberrry Pi - Parte 2: Instalación de Raspbian y configuración inicial

En esta entrada nos vamos a centrar en instalar Raspbian en el Raspberry Pi y en configurar algunas opciones iniciales. La más importante será habilitar el servidor SSH para poder acceder a él remotamente.

Instalar Raspbian es tan fácil como seguir los pasos de la entrada que lo explicaba en su momento. Una vez hecho, introducimos la tarjeta en el Raspberry, conectamos un teclado, un monitor (sólo hará falta esta vez) y un cable de red, que conectaremos a su vez a nuestro router. Al encender el Raspberry, tras unos cargar el sistema nos saldrá el asistente de configuración inicial de Raspbian, que nos facilitará activar ciertas cosillas de una forma muy sencilla. Vamos a analizarlo por encima:

• La primera opción del menú simplemente muestra un mensaje que explica básicamente lo que he contado aquí. Añade también que este configurador se puede usar más adelante, si queremos modificar alguna opción en concreto. Para ello, basta con escribir en el terminal: sudo raspi-config
• La segunda opción es expand_rootfs y lo que hace es redimensionar la partición root de la tarjeta SD hasta ocupar todo el espacio disponible de la misma. Cuando hemos instalado el Raspberry en nuestra tarjeta, lo que hemos hecho es grabar una imagen del sistema operativo. Según la web oficial se necesita una tarjeta de al menos 2GB, por lo que la imagen estará pensada para no ocupar más de 2GB. Con esta opción ampliamos el espacio disponible de nuestro sistema operativo de modo que utilice todo el que haya disponible en la tarjeta.
• La opción overscan se utiliza cuando al conectar el Raspberry con a la pantalla vemos que o bien la imagen ocupa menos, obteniendo bordes negros, o que ocupa más, y no vemos la imagen completa.
• La opción configure_keyboard permite seleccionar qué distribución de teclado usaremos. Por defecto se usa la distribución americana, por lo que los acentos y varios símbolos no están donde estarían en un teclado español.
• change_pass permite cambiar la contraseña del usuario pi (que inicialmente es raspberry)
• change_locale permite cambiar el idioma por defecto del sistema. Inicialmente es inglés. Afecta al idioma que tendrán los programas cuando se instalen, los menús, etc.
• change_timezone permite cambiar la zona horaria.
• memory_split: El Raspberry tiene 256 o 512 MB de RAM. Esta memoria la utiliza por un lado la CPU y por otro la GPU. Esta opción permite establecer cuánta memoria usará la GPU, de modo que el resto será para la CPU.
• overclock: Sirve para aumentar la frecuencia de la CPU del Raspberry. Tengo que informarme más porque leí en la página oficial que, al hacer overclocking, automáticamente se anulaba la garantía del Raspberry, pero que había una opción en las últimas versiones de Raspbian que la habían probado y que no la anulaba. Ten en cuenta que aumentar la frecuencia de la CPU puede reducir la vida útil del Raspberry.
• ssh: Habilita o deshabilita el servidor SSH, permitiendo usar el Raspberry sin necesidad de pantalla o teclado.
• boot-behaviour: por defecto, Raspbian se inicia en modo texto, y si queremos cargar el entorno gráfico debemos escribir startx en la consola. Mediante esta opción podemos hacer que el entorno gráfico se cargue automáticamente.
• update: esta opción permite actualizar el propio asistente si tenemos conexión a Internet.

 

Configuración inicial con Raspi-config

Vamos a ponernos manos a la obra:

1. Como hemos conectado el Raspberry a Internet con el cable de red, lo primero que haremos es comprobar si hay actualizaciones con la opción update.
2. A continuación expandiremos el sistema de archivos con la opción expand_rootfs.
3. Pondremos el teclado en español con configure_keyboard.
4. Cambiamos la contraseña por defecto por una nueva. Intenta que sea segura, ya que es la que nos preguntará el sistema cuando queramos conectarnos desde Internet.
5. Si queremos cambiar el idioma del sistema, lo haremos con la opción change_locale. Yo lo he dejado en inglés. Si queremos usar el español, bajaremos por la lista y seleccionaremos (pulsando espacio) es_ES.UTF-8, como se ve en la imagen. Para aceptar tendremos que usar tabulador e intro.
6. De un modo similar, seleccionaremos nuestra zona horaria con la opción change_timezone. En mi caso he seleccionado Europa y Madrid.
7. Seleccionamos memory_split para repartir la RAM del sistema. Como estamos haciendo un cliente de torrent, que no va a necesitar la GPU para nada, podemos usar casi toda la RAM para la CPU. Yo he seleccionado 64 MB para GPU y el resto para la CPU, pero puedes usar incluso menos, especialmente si tu Raspberry es la versión de 256 MB.
8. Seleccionamos la opción SSH y lo activamos.
9. El resto de opciones las dejamos por defecto y seleccionamos finish. Finalmente reiniciamos la máquina escribiendo sudo reboot.

Al cabo de unos segundos, el sistema se reiniciará y aparecerá una terminal. Sólo nos queda averiguar la dirección IP y la MAC de nuestro Raspberry. Para ello escribimos: ifconfig eth0

Nuestra dirección IP es la que aparece después de inet addr: y nuestra MAC será la que aparece detrás de HWaddr. Las anotamos, ya que las vamos a utilizar para conseguir una IP fija en nuestra red.

Configurando router para conseguir IP fija en el Raspberry

Lo que vamos a hacer es decirle a nuestro router que queremos que nos reserve una dirección IP concreta para nuestro Raspberry, de modo que siempre que esté conectado al router, tendrá la misma IP.

Este procedimiento varía de un router a otro. En mi caso lo voy a explicar con un router ASL-26555 que es el que te da Movistar al contratar Fusión. De todas formas el proceso es similar con el resto de routers, aunque los nombres pueden variar un poco.

1. Estando conectados al router por Wifi o Cable desde nuestro ordenador, accedemos a la web de configuración del router. En mi caso es http://192.168.1.1:8000/ aunque en otros routers puede ser simplemente http://192.168.1.1
2. Accedemos con el usuario y contraseña del router. Esto también depende de cada modelo, y es muy recomendable cambiarlo, ya que sino cualquier persona conectada a nuestra red podría acceder a nuestro router simplemente consultando cuál es la contraseña por defecto del mismo. 
3. En mi caso, en la pestaña Local Network está la opción Add Static IP Address. Basta con escribir la MAC del Raspberry y la IP que queremos asignarle, marcar la opción Enable y pulsar Add/Apply. Con esto añadiremos el Raspberry a la lista de reserva de IP, que se puede ver justo debajo:

Con esto ya tenemos nuestro Raspberry configurado y listo para trabajar. Podemos desconectar la pantalla y el teclado, ya que no serán necesarios a partir de ahora.

Accediendo al Raspberry mediante SSH

¿Recuerdas que cuando estábamos configurando el Raspberry habilitamos la opción de SSH Server? SSH (Secure Shell) es un protocolo de comunicaciones que permite conectarnos a una máquina (como nuestro Raspberry) de forma remota. Esto quiere decir que podemos utilizar es Raspberry desde nuestro portátil, desde el móvil o desde un PC que esté en cualquier lugar con conexión a Internet.

Para ello, necesitamos un cliente SSH, que es un programa que nos permite conectarnos al Raspberry. Yo en Windows uso Putty, y en Linux puedes conectarte directamente desde un terminal.

Si usas Putty, al abrirlo te encontrarás algo parecido a ésto:

Aunque haya muchísimas opciones, usar Putty es tan sencillo como escribir la IP del Raspberry (la que configuramos antes en el router y vimos con ifconfig) en la casilla Host Name (or IP address) y pulsar Open.

Se abrirá una terminal donde al cabo de un momento y si todo ha ido bien,  mostrará: login as: Escribiremos pi y acto seguido nos preguntará por la contraseña, donde pondremos la contraseña que establecimos antes.

Deberíamos tener algo parecido a la imagen anterior. Si es así, ya tendremos todo listo para empezar a instalar y configurar nuestro cliente torrent en el Raspberry. Pero eso será en la siguiente entrada.

PD: He intentado que el tutorial sea lo más claro posible, pero ante cualquier duda, usad los comentarios.