Añadir bluetooth a un amplificador Yamaha RX-V461

Estoy muy contento con mi amplificador Yamaha RX-V461, con el que escucho música en el salón y al que tengo conectado el Blu-Ray, la televisión, ordenador, etc.

Amplificador Yamaha RX-V461

Lo compré hace más de 10 años y solo le pongo dos pegas:

  1. Que ya le fallan algunos botones del mando a distancia, entre ellos los dos botones de volumen, que lo hacen casi inservible…
  2. Que no tiene bluetooth

La primera de las pegas, el que le fallen los botones del mando tiene fácil solución, y la contaré en otra entrada más adelante.

Hoy voy a contar cómo resolví anoche en apenas una hora la segunda de las pegas, el que no tenga bluetooth y por tanto no pueda reproducir música desde el móvil, por ejemplo.

Es de estos proyectos sencillos (bueno, requiere su técnica), pero muy gratificantes, como el de cuando transformé un altavoz Bose SoundDock con el conector de iPod roto y le añadí bluetooth, una entrada de línea y control de volumen (ver esta entrada).

Voy a introducirle un módulo de bluetooth VHM-314, que es muy común y barato (compré este, por poco más de 5€):

VHM-314 bluetooth audio receiver board bluetooth 4.1mp3 lossless ...
Módulo bluetooth VHM-314

Es muy pequeño, de unos 3 cm x 3 cm.

Buscaré dentro del amplificador algún punto de 5V, y buscaré también una entrada adecuada de audio al que dejarlo conectado.

Quito la tapa del aparato y me pongo a buscar dónde robar 5V… Tras descartar varias alternativas me decanto por la entrada de USB, que se alimenta con 5V. Sigo la conexión de USB y llego a la placa de la que parte. Ahí está muy bien indicada la alimentación. Mido por si acaso con el polímetro y son 5.0V clavados.

Decidir a qué entrada de audio conectarlo es más difícil. Primero, no quiero condenar ninguna entrada que ya use o que pueda usar en el futuro. Al principio barajé poner un interruptor para poder desactivarlo si quisiese, y así podría usar cualquier entrada para su uso original, pero al final lo descarté. Y en segundo lugar, prefiero que sea una entrada accesible para soldar sin muchos problemas y no tener que desmontar demasiado.

Al final me decanto por la entrada de audio de la grabadora de MiniDisc/CD, que ni he usado en mi vida, ni tengo el aparato, ni creo que nadie use nunca más. Pero el motivo principal es que es la entrada más accesible, y solo tengo que desmontar dos plaquitas que me estorban un poco (la caja de la antena, y el bloque de conectores de los altavoces).

Entrada de audio de grabadora de MiniDisc / CD, a la que conectaré por dentro el bluetooth

Desmonto la cajita de la antena y echo un vistazo. Con el polímetro identifico qué pertenece a audio izquierdo, derecho y tierra.

Entrada de audio por dentro, con la cajita de antena que estaba encima ya desmontada.

Desmonto también la placa de conectores de altavoces.

Entrada de audio a la que voy a conectar el bluetooth, ya con la placa de altavoces quitada para facilitar acceso

Y con mucha paciencia y pulso, sueldo los cables de audio izq, der y tierra.

Sueldo los otros extremos de estos tres cables al módulo de bluetooth, y me lo llevo todo a la zona donde voy a conectarlo a los 5V. Ahí conecto a VCC y GND los dos cables de alimentación del módulo y listo. Me dejo cable suelto por si algún día le pongo un interruptor.

Enchufo el amplificador y lo enciendo, a ver si funciona. Se enciende un led azul, así que parece que todo en orden. Vuelvo a conectar la caja de conectores de altavoces y la de la antena, y conecto un altavoz, para ver si funciona.

Con el móvil busco dispositivos bluetooth, y encuentro uno llamado VHM-314 (es una pena que no se pueda cambiar el nombre). Me conecto a él, pongo una canción, juego en la cadena a encontrar el modo de audio adecuado, subo el volumen y ¡voilá! ¡funciona! Subo el volumen bastante alto (sin pasarme, que era de noche) y se oye muy bien.

Con un poco de cinta de doble cara pego el módulo a una placa que está ahí muy a mano.

Cierro la tapa, y ya está, como nuevo, pero ahora con bluetooth.

Referencias

«Botón sin contacto» con sensor ultrasónico HC-SR04 en tiempos de COVID-19

En una entrada de hace un par de semanas describía cómo construir un «botón sin contacto», por medio de una célula fotoeléctrica, en previsión que este tipo de interruptores van a utilizarse mucho más a partir de ahora, en este nuevo mundo durante y tras COVID-19…

Cuento ahora otro botón «sin contacto» también muy sencillo, empleando el sensor ultrasónico HC-SR04.

El concepto detrás de este sensor es muy sencillo: se emite un pulso de alta frecuencia que tras rebotar en un objeto es captado de vuelta por un micrófono. Midiendo el tiempo entre la señal emitida y la recepción de su rebote se puede calcular la distancia a la que se encuentra el objeto en cuestión.

HC-SR04
Sensor ultrasonidos HC-SR04
HC-SR04 frontal
HC-SR04 frontal
HC-SR04 parte trasera
HC-SR04 parte trasera

Según la hoja de especificaciones, se alimenta de 5V y su rango de medida está entre 2 cm y 400 cm, con un ángulo de 15º. Es un sensor muy típico y barato (menos de 2€).

Instalo la librería NewPing desde el IDE de Arduino, y conecto de la siguiente forma:

HC-SR04 -> Arduino Pro Micro (Leonardo):
Vcc -> VCC
Trig -> 5
Echo -> 5
Gnd -> GND

Puede conectarse «Trig» y «Echo» a pines diferentes, pero con la librería «NewPing», que se puede instalar directamente desde el IDE de Arduino, se puede emplear un mismo pin, en mi caso el 5. A fin de cuentas, cuando se está emitiendo la señal no se está esperando la respuesta, por lo que se puede emplear el mismo pin para los dos propósitos.

Conecto también un led (con su resistencia correspondiente), de forma que me queda conectado así:

Arudino + HC-SR04 + led
Arduino + HC-SR04 + led

Y cargo el siguiente código:

<code>#include &lt;NewPing.h>

// HC-SR04 -> Arduino Pro Micro (Leonardo):
// Vcc -> VCC
// Trig -> 5
// Echo -> 5
// Gnd -> GND

const int UltrasonicPin = 5;  // Pin al que se envía y recibe la señal del HC-SR04
const int MaxDistance = 200;
const int ledPin = 9;         // Pin al que está conectado el LED
const int distSens = 11;   // Distancia por debajo de la cual se enciende el led

int dist;

NewPing sonar(UltrasonicPin, UltrasonicPin, MaxDistance);
 
void setup() {
  Serial.begin(9600);
}
 
void loop() {
  delay(50);                      // esperar 50ms entre pings (29 ms como mínimo)
  dist=sonar.ping_cm();
  Serial.print(dist);
  Serial.println("cm");

  if (dist &lt; distSens)
  {
    Serial.println("Enciendo");  
    digitalWrite(ledPin, HIGH);
    delay(50);
    Serial.println("Apago");  
    digitalWrite(ledPin, LOW); 
  }
  
}</code>

En el vídeo del principio puede verse en funcionamiento.

Referencias

«Botón sin contacto» con célula fotoléctrica en tiempos de COVID-19

En los tiempos que nos ha tocado vivir con la crisis del COVID-19 previsiblemente vamos a tener que habituarnos a un nuevo escenario vital, en el que deberemos cambiar ciertos hábitos y formas de relacionarnos entre las personas y de interactuar con los objetos, al menos por un tiempo.

Entre otras cosas, es de esperar que cada vez más se evite en la medida de lo posible tocar cosas que tocan otras muchas personas, como interruptores, por lo que seguramente se tenderá a interruptores sin contacto.

Describo aquí uno de esos tipos de botones, que pretendo emplear en un próximo proyecto (un termómetro infrarrojo sin contacto, para que por ejemplo las personas de una oficina puedan tomarse la temperatura de forma inmediata y sin contacto, estando colocado el aparatito en una zona común, como puede ser el baño…)

La verdad es que es uno de los proyectos más simples que puede haber: tomar lecturas de una célula fotoeléctrica y si se cumple cierto criterio (que baja la intensidad en un breve tiempo para luego recuperarse, que es lo que ocurre al pasar la mano por delante «a lo Jedi») enciende un LED.

En el fondo, es el mismo tipo de interruptor de los grifos automáticos:

Grifo Automatico Con Sensor En Cuello Recto Valvula Ysg8007 ...

Lo he hecho con un Arduino Micro (Leonardo), conectando los componentes según el siguiente diagrama:

555 bc0rol83ox
Diagrama Fritzing de conexión (tomado de aquí)

El código que he creado es el siguiente:

<code>const int ledPin = 9;
const int fotoresistPin = 0;
const int sensibilidad = 5;
const int tiempoSens1 =200;
const int tiempoSens2 =50;

int valor;
int valorAnt;
int valorPrev;

void setup() {
Serial.begin(9600);
}

void loop() {
  valor = analogRead(fotoresistPin);
  Serial.print("Valor :");
  Serial.println(valor);
  valorPrev = valor;

  if (valor &lt; valorAnt - sensibilidad)
  {
    delay(tiempoSens1);
    valor = analogRead(fotoresistPin);
    if (valor >= valorPrev)
    {
    Serial.println("Enciendo");  
    digitalWrite(ledPin, HIGH);
    delay(50);
    Serial.println("Apago");  
    digitalWrite(ledPin, LOW); 
    }
  }

  valorAnt = valor;
  
  delay(tiempoSens2);

}</code>

Y en el siguiente vídeo se puede ver en funcionamiento:

Referencias

Run run se fue pa’l Norte para coro

Hace unos meses escuché un programa en la radio que hablaba sobre la cantante chilena Violeta Parra, contando su historia de desamor con su amado Run Run. De fondo, sonaba la canción que compuso sobre su desgracia. Me pareció desgarradoramente realista, además de preciosa.

El ritmo es un «rin» (taca taca ta ta), muy característico del charango (una bandurria con 5 dobles cuerdas).

Esta es la canción de Violeta Parra:

Y esta la versión de Inti Illimani, que fue la que sonaba en el programa de radio, muy conocida:

He hecho un arreglo para coro SATB, acompañado de guitarra, charango (curiosamente mi amigo Ramón, que canta en el coro, ¡lo toca!), flauta, violonchelo y bajo eléctrico. Aquí va el vídeo:

Descargas:

NOTA: Hice este arreglo sin ánimo de lucro. No he cobrado ni cobro por el arreglo, ni permito su uso con ese fin.

Eye of the Tiger para coro SATB

Arreglo de «Eye of the Tiger» de Survivor (Frankie Sullivan & Jim Peterik) para coro SATB + guitarras eléctrica + bajo eléctrico + batería.

Aquí va el vídeo:

Descargas:

NOTA: Hice este arreglo sin ánimo de lucro. No he cobrado ni cobro por el arreglo, ni permito su uso con ese fin.

Can’t help falling in love para coro SATB

Arreglo de «Can’t help falling in love» para coro, de George David Weiss, Hugo Peretti y Luigi Creatore, según la cantaba Elvis. Arreglo para coro SATB, clarinete en Si bemol, guitarra eléctrica, bajo eléctrico y batería.

Aquí va el vídeo:

Descargas:

NOTA: Hice este arreglo sin ánimo de lucro. No he cobrado ni cobro por el arreglo, ni permito su uso con ese fin.

Billie Jean para coro SATB

Hace unos meses preparé un arreglo de Billie Jean (de Michael Jackson) para coro y unos pocos instrumentos. Subo ahora las partituras, vídeo y audios.

Aquí va el vídeo con la partitura:

Descargas:

 

NOTA: Hice este arreglo sin ánimo de lucro. No he cobrado ni cobro por el arreglo, ni permito su uso con ese fin.

Monitorización temperatura hormigón con Raspberry Pi

Quiero monitorizar la evolución en el tiempo de la temperatura de una masa de hormigón armado de gran espesor en tres puntos de su volumen durante su fraguado. Para ello, voy a disponer 4 sondas DS18B20 en el interior de la masa (en el centro, y cerca de las caras), y un sensor DHT22 en el exterior para controlar la temperatura y humedad ambientes, conectados todos a una Raspberry Pi que irá registrando los valores cada minuto, archivándolos en un pincho USB, y enviándolos por correo electrónico cada hora.

Materiales

  • Raspberry Pi. Vale cualquier modelo. Yo he empleado una Raspberry Pi B+ v1.2 que tenía disponible. Aprox 20€.
  • Tarjeta SD 16 GB. Valdría con una de 8 GB, lo suficiente para una instalación de Raspbian.
  • Memoria USB. Cualquier pincho USB que tengamos.
  • 4x DS18B20 sumergibles. Comprados aquí por 2.59€ la unidad. Total: 7.77€
  • Sensor DHT22 de temperatura y humedad, para monitorizar la temperatura y humedad ambientes
  • 5m cable CAT5
  • Modem 3G USB
  • Caja Estanca IP55, o un tupper.
  • Batería

Preparo los sensores

Los DS18b20 vienen con 1 m de cable. Como necesito algo más de longitud, empalmo un par de metros más por cada sensor y luego los junto todos a un cable de 5m. El tipo de cable que empleo es RJ45.

Hasta los 10m de longitud aproximadamente me basta con soldar entre dos de los cables una resistencia de 4.7kohm. Para longitudes mayores, en esta página hablan de la resistencia pull-up a disponer en función de la longitud del cable.

Tras soldar todos los cables, los protejo con cola térmica, y luego con cinta aislante.

Código para registrar las temperaturas

En esta entrada ya hablé de cómo usar un sensor DS18B20 con una Raspberry Pi, y esta otra, del sensor DHT22. Antes de la conexión definitiva hago pruebas con cada uno de los sensores por separado para ver que está todo en orden.

Básicamente, sigo los pasos que indiqué en la entrada en la que hablé del DS18B20 para probar que funcionan cada uno de los sensores. Una vez que averiguo el identificador de cada uno de los sensores, preparo este pequeño script en Python que registra la temperatura de los sensores en un fichero:

# -*- coding: utf-8 -*-

import os	#Para poder pasar comandos al sistema (sudo modprobe...)
import time	#Para poder sacar la hora del sistema
import logging	#Para loguear los eventos
import Adafruit_DHT	#Para poder usar el DHT


termo1 = "28-0417838399ff"
termo2 = "28-041783898fff"
termo3 = "28-04178386dbff"
termo4 = "28-04178389e9ff"

sensor = Adafruit_DHT.DHT22
pin = 24	#Pin donde está conectado el DHT22


#Cargo los módulos para el termómetro:
os.system("sudo modprobe wire")
os.system("sudo modprobe w1-gpio")
os.system("sudo modprobe w1-therm")


#Inicializo el log:
logging.basicConfig(filename='/media/pincho/temps.log',level=logging.INFO,format='%(asctime)s %(message)s')

#Función para obtener la hora del sistema:
def get_date_time():
	return time.strftime("%d/%m/%Y,%H:%M:%S")

#Función para obtener la temperatura de un termómetro:
def get_temp_sens(term):
	try:
		ruta = "/sys/bus/w1/devices/" + term + "/w1_slave"
		tfile = open(ruta)
		text = tfile.read()
		tfile.close()
		secondline = text.split("\n")[1]
		temperaturedata = secondline.split(" ")[9]
		temperature = float(temperaturedata[2:])
		temperature = temperature / 1000
		temperature = round (temperature,1)
	except:
		temperature = 0
	return float(temperature)

#Función para obtener la temperatura y humedad del DHT22:
def get_tempYhum():
        try:
                humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)
		temperature = round (temperature,1)
		humidity = round (humidity,1)
	except:
		humidity = 0
                temperature = 0
        return float(temperature), float(humidity)


hora = get_date_time()
temp0,humedad = get_tempYhum()
temp0 = str(temp0)
humedad  = str(humedad)
tempsens1= str(get_temp_sens(termo1))
tempsens2= str(get_temp_sens(termo2))
tempsens3= str(get_temp_sens(termo3))
tempsens4= str(get_temp_sens(termo4))


linealog = hora + \
"," + temp0 + \
"," + humedad + \
"," + tempsens1 + \
"," + tempsens2 + \
"," + tempsens3 + \
"," + tempsens4

print(linealog)

logging.info(linealog)

Conexión de los sensores

Para conectar los DS18B20, decido emplear un conector RJ45 (para facilitar la conexión en obra) que saco de una tarjeta de red vieja que tenía por ahí (ni siquiera la desueldo, directamente la corto con una sierra:

Y le sueldo la resistencia y los cables que conectaré a la Raspberry Pi:

Configuro la Raspberry Pi

  • Descargo la última versión de Raspbian (Raspbian Stretch, 2018-03-13) y la instalo en una tarjeta SD con Etcher
  • Configuro Raspbian para poder acceder desde SSH, configuro los locales y teclado, etc. La nombro RaspiHormiMon
  • Creo un túnel reverso SSH, siguiendo las instrucciones que preparé en esta entrada.

Conecto el pincho USB

Además de enviar los datos por internet, voy a archivar los registros en un pincho USB. Para ello tengo que instalarlo y garantizar que se cargue siempre en el arranque, modificando /etc/fstab. Sigo los pasos que ya conté en esta entrada.

Conexión a internet

Pensaba que tendría que seguir los pasos de esta entrada que escribí hace un par de años, pero compruebo que al conectar el Huawei E303 con una tarjeta SIM con el pin deshabilitado, la Raspberry Pi la reconoce perfectamente (en las últimas versiones de Raspbian viene por defecto usbmodeswitch) sin necesidad de hacer nada y se conecta automáticamente a internet como si fuese una conexión alámbrica, eth1.

Que envíe el log por email

Configuro la Raspberry Pi para que pueda enviar ficheros por correo, siguiendo los pasos que cuento en esta entrada.

Crontab

Ahora añado las siguientes líneas al crontab para que se ejecuten las tareas descritas anteriormente:

  • Registro de temperaturas cada minuto
  • Envío por correo electrónico del fichero de registros cada hora

Ejecuto:

crontab -e

Y añado las dos siguientes líneas:

* * * * * sudo python /home/pi/logsens.py
0 * * * *  mpack -s "Log Temps" /media/pincho/temps.log direccionDeCorreo@dominio.com

Batería y alimentación

Como pretendo dejar el invento en una obra, que estará alimentado a saber de qué forma (un grupo electrógeno seguramente), le pongo una batería, que permita seguir funcionando si se va un rato la luz, y también que proteja de las subidas de tensión.

La alimentación se hará por medio de un cargador convencional micro-usb de 5V (los de los móviles).

Carcasa

Con todo ya listo, lo meto dentro de una caja IP55, que es relativamente estanca, y de dimensiones perfectas para encajar todo sin estar muy apretado.

Montaje en obra

Tengo que decir que yo no pude colocar los sensores en obra y los colocó mi compañero y amigo Jorge. Como no podía ser de otra forma, estuvo lloviendo mientras lo colocaba, por lo que ¡se empapó enterito!

Aquí van una serie de fotos de la colocación de los sensores en obra:

Resultados

La Raspberry Pi tomaba medidas cada minuto, y enviaba un correo electrónico con todo el registro cada hora.

Versión 2

Código revisado, que incorpora los leds de aviso de si hay un error cada minuto, para poder comprobar en obra una vez instalado que está todo en orden, sin tener que esperar a recibir el mensaje cada hora. En caso de haber algún problema, y tras descartar error en conexiones, podría ajustarse la resistencia variable (potenciómetro).

También instalé 5 conectores RJ-45, para poder conectar directamente varios cables y no tener que hacer laboriosos empalmes como tuve que hacer en la ocasión anterior…

 

Enviar correos con la Raspberry Pi desde la línea de comandos

Para un proyecto que tengo entre manos necesito poder enviar automáticamente un fichero con un log por correo electrónico desde una Raspberry Pi. Esto se hace con los programas ssmtp y mpack. En esta página se explican muy bien los pasos, que seguí más o menos al pie de la letra.

Primero instalo el programa ssmtp:

sudo apt-get update
sudo apt-get install ssmtp

Ahora edito el fichero de configuración:

sudo nano /etc/ssmtp/ssmtp.conf

Comento los parámetros que vienen por defecto y pego lo siguiente (tuve que darle varias vueltas hasta hacerlo funcionar):

root=midireccion@miservidor.com
mailhub=smtp.miservidor.com:465
rewriteDomain=miservidor.com
AuthUser=midireccion@miservidor.com
AuthPass=micontraseña
FromLineOverride=YES
UseTLS=YES

También tengo que editar el siguiente fichero:

sudo nano /etc/ssmtp/revaliases

Y pego al final del todo:

pi:midireccion@miservidor.com:smtp.miservidor.com:465

Y ahora pruebo a enviar un correo:

ssmtp direccionDeCorreo@dominio.com
subject: prueba
funciona?

Y envío el correo pulsando Ctrl+D.

¡Funciona!

Ahora quiero poder enviar un fichero adjunto. Para ello tengo que instalar el programa mpack:

sudo apt-get install mpack

Y para enviar un fichero por correo es tan sencillo como ejecutar:

mpack -s "Este es el asunto" fichero.txt direccion@correo.com

Túnel reverso SSH

Voy a contar un método muy útil para poder acceder a un servidor remoto al que por diversos motivos en principio no tenemos acceso directo por SSH, creando un túnel reverso tenebroso por SSH.

Una aplicación podría ser para poder acceder a una Raspberry Pi que tiene conexión a internet por medio de un modem 3G de la que desconocemos la IP (y que probablemente aún conociéndola, el ISP no nos dejaría acceder a la misma por SSH). Es el caso que tengo entre manos para una Raspberry Pi que quiero dejar monitorizando unas temperaturas de fraguado del hormigón en una obra, que cuento en esta entrada.

Necesitamos en primer lugar un Servidor A al que tenemos acceso por SSH. Podría ser una Raspberry Pi ubicada dentro de una red, y a la que podemos acceder desde fuera de la red. Para ello es muy posible que hayamos tenido que redirigir puertos del Router de la red a la misma, como es mi caso. Tengo el router configurado para que cualquier petición de conexión a un puerto concreto, digamos el 22122, se redirija al puerto 22 de la Raspberry Pi, que está escuchando y esperando conexiones SSH por ese puerto.

Tengo además instalado un servicio externo de DNS (en mi caso el gratuito No-IP) en ese Servidor A de forma que se le asigne un determinado nombre al host a la IP dinámica que mi ISP me ofrece. Digamos que ese nombre es miServidor.com

Desde el Servidor B (la Raspberry Pi con conexión 3G a internet, a la que voy a querer poder acceder en el futuro) pruebo a conectarme al Servidor A:

ssh usuarioMiServidorA@miServidor.com

Introduzco la contraseña del usuario usuarioMiServidor, y listo, ya esto conectado desde el Servidor B al Servidor A por SSH.

Habiendo comprobado que tengo acceso, salgo:

exit

Y ahora vuelvo a entrar, pero con el siguiente comando:

ssh -N -R 2222:localhost:22 usuarioMiServidorA@miServidor.com -p 22122

Y vuelvo a introducir la contraseña para conectarme (más abajo veremos cómo evitar tener que introducir la contraseña). Con esto lo que le estoy diciendo al Servidor A es que que toda conexión que le llegue al puerto 2222 (por ejemplo) lo redirija por el túnel al puerto 22. La opción -N es específica para redireccionamiento de puertos, e indica que no viene un comando después.

Y ahora, desde el Servidor A, abro el túnel para conectarme con el Servidor B, que básicamente consiste en redirigir todo el tráfico SSH a un determinado puerto:

ssh -l usuarioServidorB -p 2222 localhost

Introduzco la contraseña del usuarioServidor B y ¡ya estoy en el Servidor B!

Hasta aquí todo bien, pero nos quedan cosas por hacer. Por un lado, como en teoría no voy a tener acceso al Servidor B al iniciar la conexión, es necesario que se conecte por SSH sin necesitar introducir la contraseña. Y por otro, tendremos que tener algún tipo de servicio que se encargue de vigilar que el túnel está funcionando, y volver a abrirlo en el caso de que se haya caído.

Acceso SSH por medio de certificado

En el Servidor B (desde el que quiero acceder al Servidor B sin que me pida la contraseña), tengo que generar el par de claves público-privada. :

cd ~/.ssh

ssh-keygen -t rsa

Doy al enter varias veces aceptando las opciones por defecto, sin passphrase. Con esto se generan dos ficheros: id_rsa y id_rsa.pub.

Ahora copiamos la clave pública al Servidor A:

scp -P 22122 id_rsa.pub usuarioServidorB@servidorB:.ssh/authorized_keys

(O lo copiamos con un pincho USB o como se quiera.)

Ahora pruebo a conectarme desde el Servidor B al Servidor A, y a ver si no me pide la clave:

ssh usuarioMiServidorA@miServidor.com -p 22122

Si a la hora de hacer la conexión tenemos algún problema, puede interesar empelar el comando con la opción -v, y ver lo que pasa:

ssh -v usuarioMiServidorA@miServidor.com -p 22122

¡Funciona!

Control de la conexión

Ahora tenemos que comprobar que el túnel permanece abierto a lo lagro del tiempo, y garantizar que se reconecta en caso de pérdida de que lo haya perdido.

Creo un fichero ~/create_ssh_tunnel.sh, con el siguiente contenido (sacado y adaptado de aquí):

#!/bin/bash
createTunnel() {
/usr/bin/ssh -N -R 2222:localhost:22 pi@miServidor.com -p 22122
if [[ $? -eq 0 ]]; then
echo Tunnel to jumpbox created successfully
else
echo An error occurred creating a tunnel to jumpbox. RC was $?
fi
}
/bin/pidof ssh
if [[ $? -ne 0 ]]; then
echo Creating new tunnel connection
createTunnel
fi

Este script comprueba que haya un proceso ssh ejecutándose, y si no, abre el túnel.

Hacemos ejecutable el script:

chmod 700 ~/create_ssh_tunnel.sh

Modifico crontab para que se ejecute cada minuto:

crontab -e

Y añado al final del fichero:

*/1 * * * * ~/create_ssh_tunnel.sh > tunnel.log 2>&1
Con esto decimos que se ejecute el script cada minuto.

Y listo, ya está funcionando.

Referencias

https://blog.devolutions.net/2017/3/what-is-reverse-ssh-port-forwarding

https://www.tunnelsup.com/raspberry-pi-phoning-home-using-a-reverse-remote-ssh-tunnel/