Internet móvil con el modem 3G USB Huawei E303 en la Raspberry Pi

En este post expliqué cómo hacer funcionar el modem 3G Huawei E173 en la Raspberry Pi. Tengo ahora un módem E303 (en concreto E303h-1), y voy a intentar lo mismo.

El Huawei E303 es un dispositivo de internet móvil que funciona con redes 3G, EDGE, GPRS, GSM, HSDPA y HSUPA, y soporta las bandas GSM de 2100, 850, 900, 1800 y 1900 MHz.

Como ya expliqué, puede ser una tarea difícil. Uno de los motivos es que estos “pinchos USB” suelen llevar una memoria interna, o una ranura para una tarjeta microUSB, y la Raspberry Pi no lo reconoce como un módem sino como un dispositivo de almacenamiento (que es la intención de los fabricantes, para que al conectarlo a un PC con Windows, este automáticamente instale los drivers desde el almacenamiento). Para solucionar esto, y que la Raspberry Pi reconozca al dispositivo como lo que es, un modem, hay que recurrir al programa usb-modeswitch, y hay que prepararse para dedicarle muchas horas de búsqueda por internet para tu configuración, y luego mil pruebas…

IMG_6242

Dispositivo Huawei E303. Vista frontal

IMG_6243

Dispositivo Huawei E303. Vista trasera

IMG_6244

Dispositivo Huawei E303. Vista sin la tapa

Conseguir que la Raspberry Pi reconozca el modem Huawei E303

Antes de nada hay que asegurarse de que nuestra Raspberry Pi está bien alimentada, pues el modem 3G puede consumir bastante corriente. Lo segundo es que hayamos quitado el pin de la tarjeta SIM que hemos introducido en el modem 3G (esto generalmente lo podremos hacer o bien desde un móvil, o desde el programita/página web que salta por defecto al conectar el pincho a un PC).

Conecto el pincho y ejecuto el comando lsusb. Me sale, entre otros dispositivos USB que tengo conectados, este:

Bus 001 Device 006: ID 12d1:1f01 Huawei Technologies Co., Ltd. 

Si desconecto el pincho, ejecuto el comando tail -f /var/log/messages, y vuelvo a conectar el pincho sale:

Apr 18 10:07:25 piglobo2a kernel: [ 4792.775768] usb 1-1.4: new high-speed USB device number 7 using dwc_otg
Apr 18 10:07:25 piglobo2a kernel: [ 4792.877566] usb 1-1.4: New USB device found, idVendor=12d1, idProduct=1f01
Apr 18 10:07:25 piglobo2a kernel: [ 4792.877606] usb 1-1.4: New USB device strings: Mfr=1, Product=2, SerialNumber=3
Apr 18 10:07:25 piglobo2a kernel: [ 4792.877625] usb 1-1.4: Product: HUAWEI Mobile
Apr 18 10:07:25 piglobo2a kernel: [ 4792.877642] usb 1-1.4: Manufacturer: HUAWEI
Apr 18 10:07:25 piglobo2a kernel: [ 4792.877660] usb 1-1.4: SerialNumber: FFFFFFFFFFFFFFFF
Apr 18 10:07:25 piglobo2a kernel: [ 4792.932324] usb-storage 1-1.4:1.0: USB Mass Storage device detected
Apr 18 10:07:25 piglobo2a kernel: [ 4792.933467] scsi host2: usb-storage 1-1.4:1.0
Apr 18 10:07:26 piglobo2a kernel: [ 4793.954310] scsi 2:0:0:0: CD-ROM            HUAWEI   Mass Storage     2.31 PQ: 0 ANSI: 2
Apr 18 10:07:26 piglobo2a kernel: [ 4794.052926] sr 2:0:0:0: [sr0] scsi-1 drive
Apr 18 10:07:26 piglobo2a kernel: [ 4794.054690] sr 2:0:0:0: Attached scsi generic sg1 type 5
Apr 18 10:07:26 piglobo2a kernel: [ 4794.073335] scsi 2:0:0:1: Direct-Access     HUAWEI   TF CARD Storage  2.31 PQ: 0 ANSI: 2
Apr 18 10:07:26 piglobo2a kernel: [ 4794.075205] sd 2:0:0:1: Attached scsi generic sg2 type 0
Apr 18 10:07:26 piglobo2a kernel: [ 4794.081446] sd 2:0:0:1: [sdb] Attached SCSI removable disk

Lo está reconociendo como una unidad de almacenamiento, y no como un modem, que es lo que quiero. Entonces tengo que instalar el programa usb_modeswitch:

sudo apt-get install usb-modeswitch

Si ahora hago lsusb obtengo:

Bus 001 Device 010: ID 12d1:14dc Huawei Technologies Co., Ltd.

Es decir, ha cambiado el id original 12d1:1f01 por el nuevo 12d1:14dc.

Y si hago de nuevo tail -f /var/log/messages, obtengo:

Apr 18 10:15:12 piglobo2a kernel: [ 5260.033848] usb 1-1.4: new high-speed USB device number 11 using dwc_otg
Apr 18 10:15:12 piglobo2a kernel: [ 5260.135921] usb 1-1.4: New USB device found, idVendor=12d1, idProduct=1f01
Apr 18 10:15:12 piglobo2a kernel: [ 5260.135960] usb 1-1.4: New USB device strings: Mfr=1, Product=2, SerialNumber=3
Apr 18 10:15:12 piglobo2a kernel: [ 5260.135980] usb 1-1.4: Product: HUAWEI Mobile
Apr 18 10:15:12 piglobo2a kernel: [ 5260.135998] usb 1-1.4: Manufacturer: HUAWEI
Apr 18 10:15:12 piglobo2a kernel: [ 5260.136018] usb 1-1.4: SerialNumber: FFFFFFFFFFFFFFFF
Apr 18 10:15:13 piglobo2a kernel: [ 5260.267266] usb-storage 1-1.4:1.0: USB Mass Storage device detected
Apr 18 10:15:13 piglobo2a kernel: [ 5260.276429] scsi host6: usb-storage 1-1.4:1.0
Apr 18 10:15:13 piglobo2a usb_modeswitch: switching device 12d1:1f01 on 001/011
Apr 18 10:15:14 piglobo2a kernel: [ 5261.336395] usb 1-1.4: USB disconnect, device number 11
Apr 18 10:15:14 piglobo2a kernel: [ 5261.823824] usb 1-1.4: new high-speed USB device number 12 using dwc_otg
Apr 18 10:15:14 piglobo2a kernel: [ 5261.925562] usb 1-1.4: New USB device found, idVendor=12d1, idProduct=14dc
Apr 18 10:15:14 piglobo2a kernel: [ 5261.925603] usb 1-1.4: New USB device strings: Mfr=1, Product=2, SerialNumber=0
Apr 18 10:15:14 piglobo2a kernel: [ 5261.925623] usb 1-1.4: Product: HUAWEI Mobile
Apr 18 10:15:14 piglobo2a kernel: [ 5261.925643] usb 1-1.4: Manufacturer: HUAWEI
Apr 18 10:15:14 piglobo2a kernel: [ 5262.165445] cdc_ether 1-1.4:1.0 eth1: register 'cdc_ether' at usb-bcm2708_usb-1.4, CDC Ethernet Device, 00:1e:10:1f:00:00
Apr 18 10:15:14 piglobo2a kernel: [ 5262.167221] usb-storage 1-1.4:1.2: USB Mass Storage device detected
Apr 18 10:15:14 piglobo2a kernel: [ 5262.168907] scsi host7: usb-storage 1-1.4:1.2
Apr 18 10:15:15 piglobo2a kernel: [ 5263.169241] scsi 7:0:0:0: Direct-Access     HUAWEI   TF CARD Storage  2.31 PQ: 0 ANSI: 2
Apr 18 10:15:15 piglobo2a kernel: [ 5263.173135] sd 7:0:0:0: [sdb] Attached SCSI removable disk
Apr 18 10:15:15 piglobo2a kernel: [ 5263.175278] sd 7:0:0:0: Attached scsi generic sg1 type 0

Lo que está pasando es que la Raspberry Pi está reconociendo al modem 3G como una interfaz de red, pues este modem tiene esa propiedad HiLink de algunos Huawei.

Con esto ya tenemos una nueva “tarjeta de red”, y podríamos empezar a navegar haciendo lo siguente:

sudo nano /etc/network/interfaces

y añadimos este nuevo dispositivo ethernet eth1:

auto lo

iface lo inet loopback
iface eth0 inet dhcp

<strong>iface eth1 inet dhcp</strong>

allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp

Reiniciamos, y el pincho nos asignará la IP 192.168.8.100.

Y ya tenemos conexión a internet en la Raspberry Pi a través del pincho Huawei E303.

No hemos acabado todavía…

Pero yo quiero emplear este pincho para mandar SMS también, así que este procedimiento tan sencillo y maravilloso no me vale, pues no se reconoce el modem como tal. Tengo que especificar a usb-modeswitch que cambie no al modo HiLink, sino a otro modo.

Lo primero, editamos el fichero /etc/usb_modeswitch.conf haciendo que EnableLogging=1. De esta forma, el fichero de registro /var/log/usb_modeswitch_XXXXXXXXXXXX contendrá más información, que nos será muy útil en todas las pruebas que seguramente tengamos que hacer.. Cada vez que desconecte y reconecte el modem USB, veré el contenido de ese fichero para ver los pasos que sigue el programa.

En la página web de Usb_modeswitch se explica muy bien el funcionamiento del programa. Como en mi caso se cambia al modo HiLink, significa que usb_modeswitch reconoce bien el dispositivo y lo cambia correctamente, esto significa que la configuración está ya en la base de datos. Pero quiero cambiar al otro modo.

Continuo probando. En el fichero /usr/share/usb_modeswitch/configPack.tar.gz encuentro el fichero 12d1:1f01, con el siguiente contenido:

# Huawei E353 (3.se)

TargetVendor=  0x12d1
TargetProduct= 0x14db

MessageContent="55534243123456780000000000000a11062000000000000100000000000000"
NoDriverLoading=1

Hay algo raro, pues realmente carga el 14dc y no el 14db, pero me da igual, porque lo voy a pisar. Podemos hacer que usb-modeswitch pase de esta configuración y lea la que nosotros queramos, si colocamos el fichero correspondiente en /etc/usb_modeswitch.d/. Por defecto está vacío, así que voy a crear ahí el fichero con el que haré pruebas:

sudo nano /etc/usb_modeswitch.d/12d1\:1f01

(ojo con el \:). En ese fichero pego lo siguiente:

# Huawei E303
DefaultVendor= 0x12d1
DefaultProduct= 0x1f01
TargetVendor= 0x12d1
TargetProduct= 0x1001
MessageContent="55534243123456780000000000000011063000000100010000000000000000"

He llegado a esta configuración tras buscar mucho por internet y hacer muchas pruebas, pues hay varios modos que funcionan, pero sólo he encontrado éste en el que funcionase tanto GSM como 3G.

Otras configuraciones que funcionaron (sólo como 3G) fueron:

# Huawei E303
DefaultVendor= 0x12d1
DefaultProduct= 0x1f01
TargetVendor= 0x12d1
TargetProduct= 0x1442
MessageContent="55534243123456780000000000000011060000000000000000000000000000"

Y esta otra:

# Huawei E303
DefaultVendor= 0x12d1
DefaultProduct= 0x1f01
TargetVendor= 0x12d1
TargetProduct= 0x1442
MessageContent="55534243000000000000000000000011060000000000000000000000000000"

Pruebo ahora a desconectar el pincho y volverlo a conectar. Al cabo de unos segundo siempre lo acaba reconociendo. Hago lo mismo reiniciando, y siempre lo reconoce. Así que no tengo que hacer ninguna de las trampas a las que tuve que recurrir con el Huawei E173.

También podría haberlo hecho ejecutando directamente el comando:

sudo usb_modeswitch -v 0x12d1 -p 0x1f01 -V 0x12d1 -P 0x1001 -M "55534243000000000000000000000011060000000000000000000000000000" -n -I

(aunque esto me cambia a 12d1:1442)

Ahora edito el fichero /etc/usb_modeswitch.conf y vuelvo a dejar EnableLogging=0 para dejarlo todo como estaba originalmente. Reinicio un par de veces con el modem enchufado y parece que todo funciona. Así que puedo pasar al siguiente paso.

Instalando el demonio pppd, UMTSKeeper y Sakis3G

El programa más utilizado para realizar la conexión 3G es Sakis3g. Sin embargo, antes de lanzarnos a instalarlo, tenemos que saber que es muy frecuente perder la conexión 3G cada cierto tiempo, por lo que se suele recurrir a otro programa, UMTSKeeper, que está constantemente comprobando la conexión y recuperándola cuando se cae. Como este último programa instala por su cuenta Sakis, no es necesario que instalemos Sakis antes.

Así que empezamos. Lo primero es instalarse el servicio pppd:

sudo apt-get install ppp

A continuación instalamos UMTSKeeper:

cd ~
mkdir umtskeeper
cd umtskeeper
wget "http://mintakaconciencia.net/squares/umtskeeper/src/umtskeeper.tar.gz"
tar -xzvf umtskeeper.tar.gz
chmod +x sakis3g umtskeeper

Ahora, configuramos sakis:

sudo ./sakis3g --interactive 
Configruación Sakis 3G Pantalla 1

Configuración Sakis 3G Pantalla 1

Configruación Sakis 3G Pantala 2

Configuración Sakis 3G Pantalla 2

Configuración Sakis 3G Pantalla 3

Configuración Sakis 3G Pantalla 3

Configuración Sakis 3G Pantalla 4

Configuración Sakis 3G Pantalla 4

Configuración Sakis 3G Pantalla 5

Configuración Sakis 3G Pantalla 5

Configuración Sakis 3G Pantalla 6

Configuración Sakis 3G Pantalla 6

Configuración Sakis 3G Pantalla 7

Configuración Sakis 3G Pantalla 7

Si ahora hago ifconfig, obtengo, entre otras cosas:

ppp0      Link encap:Point-to-Point Protocol  
          inet addr:88.29.125.147  P-t-P:10.64.64.64  Mask:255.255.255.255
          UP POINTOPOINT RUNNING NOARP MULTICAST  MTU:1500  Metric:1
          RX packets:7 errors:0 dropped:0 overruns:0 frame:0
          TX packets:10 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:3 
          RX bytes:130 (130.0 B)  TX bytes:333 (333.0 B)

Así que efectivamente, tenemos conexión a internet por ppp0.

Y por último, configuro UMTSKeeper. Ejecuto el siguiente comando (una sola línea), que luego añadiré a /etc/rc.local para que se ejecute siempre que se arranque la Raspberry Pi:

sudo /home/pi/umtskeeper/umtskeeper --sakisoperators "USBINTERFACE='0' OTHER='USBMODEM' USBMODEM='12d1:1001' APN='movistar.es' CUSTOM_APN='movistar.es' APN_USER='0' APN_PASS='0'" --sakisswitches "--sudo --console" --devicename 'Huawei' --log --silent --monthstart 8 --nat 'no' --httpserver &amp;&gt;&gt; /home/pi/umtskeeper/error.log &amp;

Consulto el fichero /var/log/umtskeeper.log y veo que está todo en orden. Pruebo a desconectar y reconectar el pincho USB, y veo que tras medio minuto vuelve a conectarse automáticamente.

Así que he conseguido:

  1. Que la Raspberry Pi reconozca el modem USB 3G como modem y no como unidad de alamacenamiento, y que lo haga tras un reinicio
  2. Que se conecte a internet a través del modem USB
  3. Que mantenga la conexión mientras la Raspberry Pi esté fucnionando, bien tras caidas de la red, o por desenchufar-reenchufar el modem 3G

¡Prueba superada!

Referencias

Display de 4 dígitos de 7 segmentos en la Raspberry Pi

Para el monitor de bebé que estoy construyendo quiero un display en el que mostrar la temperatura de un sensor, la humedad, y ya de paso, la hora. Voy a emplear el siguiente display de 4 dígitos de 7 segmentos (ver hoja de referencia aquí):

4x7LED1

Lo compré aquí por menos de 2€. Hay varios modelos muy similares, con dos puntos entre el tercer y cuarto dígito, con algún puntito más, pero se manejan todos de la misma forma.

Buceando por google, encontré un par de páginas que explican (más o menos), cómo llegar a hacerlos funcionar conectados a una Raspberry Pi. Pongo los links más abajo.

Lo primero es conocer el funcionamiento del display, que no es más que 4 bloques (dígitos) de números que aparecen representados por 7 leds (por eso se llaman 7 segmentos, aunque en realidad este modelo tiene un led/segmento más, por el punto decimal).

220px-7_segment_display_labeled.svg

Cada segmento se numera de A a G, y el punto decimal (DP).

Como tener encendidos todos los leds que necesitásemos indistintamente al mismo tiempo para representar los números correspondientes en el display requeriría más corriente de la que la Raspberry puede proporcionar, se recurre a una técnica llamada multiplexing, que consiste en ir encendiendo sucesivamente y de forma muy rápida cada uno de los segmentos que queremos tener encendidos, de forma que el ojo humano no es capaz de percibir que en realidad no están todos encendidos al mismo tiempo.

4x7LED2

4x7LED3-2

Esquema

4x7LED5

La conexión con la Raspberry Pi la hago según el siguiente esquema, empleando una resistencia para cada segmento (las conexiones de los 4 dígitos no llevan resistencias):

FW0Y6QZI2BYJMXU.LARGE

No voy a explicar el funcionamiento del GPIO de la Raspberry Pi, pero es bastante sencillo (y maravilloso). Estudiando el código más abajo se puede entender muy fácilmente.

Y lo monto todo de manera pseudo-definitiva sobre una placa:

image2

Display de 4 dígitos de 7 segmentos. Montaje sobre placa (vista frontal)

image3

Display de 4 dígitos de 7 segmentos. Montaje sobre placa (vista trasera, con algunas soldaduras algo chapurreras)

El código que empleo para que el display actúe como un reloj es el siguiente (tomado y modificado de aquí), que guardo en un fichero llamado reloj.py:

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)

segments = (24,12,19,21,23,22,15,11)

for segment in segments:
        GPIO.setup(segment, GPIO.OUT)
        GPIO.output(segment, 0)

digits = (26,18,16,13)

for digit in digits:
        GPIO.setup(digit, GPIO.OUT)
        GPIO.output(digit, 1)

num =  {' ':(0,0,0,0,0,0,0),
        '0':(1,1,1,1,1,1,0),
        '1':(0,1,1,0,0,0,0),
        '2':(1,1,0,1,1,0,1),
        '3':(1,1,1,1,0,0,1),
        '4':(0,1,1,0,0,1,1),
        '5':(1,0,1,1,0,1,1),
        '6':(1,0,1,1,1,1,1),
        '7':(1,1,1,0,0,0,0),
        '8':(1,1,1,1,1,1,1),
        '9':(1,1,1,1,0,1,1)}

try:
        while True:
            n = time.ctime()[11:13]+time.ctime()[14:16]
            s = str(n).rjust(4)
            for digit in range(4):
                for loop in range(0,7):
                    GPIO.output(segments[loop], num[s[digit]][loop])

                if (int(time.ctime()[18:19])%2 == 0) and (digit == 1):
                    GPIO.output(11, 1)
                else:
                    GPIO.output(11, 0)

                GPIO.output(digits[digit], 0)
                time.sleep(0.001)
                GPIO.output(digits[digit], 1)

except KeyboardInterrupt:

        GPIO.cleanup()

Para ejecutarlos, basta con hacer sudo python reloj.py.

Y como lo que quiero es que el display no sólo muestre la hora, sino que también muestre la temperatura de un termómetro DS18B20 que tengo conectado a la Raspberry Pi, y que se vaya alternando la hora y la temperatura cada 5 segundos, empleo el suguiente código, que guardo en un fichero llamado relojYtemp.py:

import os #Para el termómetro
import RPi.GPIO as GPIO
import time

#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")

#Función para obtener la temperatura del sensor interior:
def get_temp_sens1():
        try:
                tfile = open("/sys/bus/w1/devices/28-00000557e1a7/w1_slave")
                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)

#print get_temp_sens1()

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)

segments = (24,12,19,21,23,22,15,11)

for segment in segments:
        GPIO.setup(segment, GPIO.OUT)
        GPIO.output(segment, 0)

digits = (26,18,16,13)

for digit in digits:
        GPIO.setup(digit, GPIO.OUT)
        GPIO.output(digit, 1)

num =  {' ':(0,0,0,0,0,0,0),
        '0':(1,1,1,1,1,1,0),
        '1':(0,1,1,0,0,0,0),
        '2':(1,1,0,1,1,0,1),
        '3':(1,1,1,1,0,0,1),
        '4':(0,1,1,0,0,1,1),
        '5':(1,0,1,1,0,1,1),
        '6':(1,0,1,1,1,1,1),
        '7':(1,1,1,0,0,0,0),
        '8':(1,1,1,1,1,1,1),
        '9':(1,1,1,1,0,1,1)}


try:
        while True:
            temp = str(int(get_temp_sens1()*10)).rjust(4)

            t_fin = time.time() + 5
            while time.time() &lt; t_fin:
                for digit in range(4):
                    for loop in range(0,7):
                        GPIO.output(segments[loop], num[temp[digit]][loop])

                    if (digit == 2):
                        GPIO.output(11, 1)
                    else:
                        GPIO.output(11, 0)

                    GPIO.output(digits[digit], 0)
                    time.sleep(0.001)
                    GPIO.output(digits[digit], 1)

            t_fin = time.time() + 5
            while time.time() &lt; t_fin:
                n = time.ctime()[11:13]+time.ctime()[14:16]
                s = str(n).rjust(4)
                for digit in range(4):
                    for loop in range(0,7):
                        GPIO.output(segments[loop], num[s[digit]][loop])

                    if (int(time.ctime()[18:19])%2 == 0) and (digit == 1):
                        GPIO.output(11, 1)
                    else:
                        GPIO.output(11, 0)

                    GPIO.output(digits[digit], 0)
                    time.sleep(0.001)
                    GPIO.output(digits[digit], 1)


except KeyboardInterrupt:

        GPIO.cleanup()

(Ya expliqué en este post cómo usar el sensor de temperatura DS180B20 con la Raspberry Pi).

Display de 4 dígitos de 7 segmentos, conectado a la Raspberry Pi junto con sensor DS18B20

Display de 4 dígitos de 7 segmentos, conectado a la Raspberry Pi junto con sensor DS18B20

Cuando me llegue el sensor de humedad, actualizaré este post para que muestre también la humedad relativa del ambiente.

El display mostrando la temperatura en la cuna

El display mostrando la temperatura en la cuna

Si queremos ahorrarnos tanto cable y programación, también se venden estos displays con un controlador incorporado, de forma que podemos conectarlos fácilmente a la Raspberry Pi por I2C. Pero son de 5 a 10 veces más caros, claro (por ejemplo, este). En otra entrada explicaré su manejo.

 

Referencias

  • http://www.instructables.com/id/Controlling-a-7-segment-4-digit-display-with-a-Ras/
  • http://www.techni.ca/2014/11/drive-7-segment-4-digit-display-with.html
  • https://www.raspberrypi.org/forums/viewtopic.php?f=37&t=91796
  • http://rpi.science.uoit.ca/lab/ssdispay/
  • http://razzpisampler.oreilly.com/ch09.html
  • http://learn.parallax.com/4-digit-7-segment-led-display-arduino-demo
  • http://ahoj.io/raspberry-pi-s-load-on-a-7-segment-display
  • http://hackyourmind.org/articles/2013/06/07/raspberry-pi-with-7-segment-display.html

 

WiFi en la Raspberry Pi con el adaptador TP-LINK TL-WN725N

Vamos a conectarnos a una red WiFi con el adaptador de red TP-LINK TL-WN725N.

Lo primero, conecto el adaptador de red USB, en mi caso un TP-LINK TL-WN725N, comprado aquí por menos de 10€. (Como veremos más adelante, este adaptador no funciona directamente en la Raspberry Pi, y hay que hacer un par de cosas para que lo reconozca)

TPLink

Si no queremos complicarnos la vida, lo más sencillo es editar el siguiente fichero:

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

Y añadir al final del mismo:

network={
    ssid="SSID(nombre)_de_la_red_wifi_a_la_que_me_quiero_conectar"
    psk="Contraseña"
}

(podríamos añadir otras configuraciones en este fichero, pero mejor empezar así).

Es posible que tengamos que editar también el fichero /etc/network/interfaces, pero en mi caso, dejándolo como viene por defecto en una instalación limpia de Raspbian funciona tanto con cable como por wifi.

Y ya estaría, si nuestra Raspberry Pi reconociese el adaptador según lo enchufas. Pero este no es el caso del TP-LINK TL-WN725N, a menos a fecha de 5 de julio de 2015. Ni siquiera aparece entre los dispositivos USb cuando ejecuto el comando sudo lsusb. Así que tenemos que hacer lo siguiente.

Lo primero, actualizo el firmware de la Raspberry Pi:

sudo rpi-update

En mi caso, se actualizó desde la versión 3.18.11+ a la 4.0.7+. Reiniciamos para que tenga efecto la actualización. Y tras reiniciar, podemos ver la versión con el siguiente comando:

uname -a

Actualizo los repositorios y todos los paquetes:

sudo apt-get update &amp;&amp; sudo apt-get upgrade

Tenemos que ver qué versión de drivers descargarnos, en función de la versión de nuestro kernel (que acabamos de actualizar). Podemos consultarlo aquí. Cuidadín, porque también dependerá de si nuestra Raspberry Pi es una Pi 2 o no. En mi caso, para la versión 4.0.7+ de una Raspberry Pi B+, será el fichero 8188eu-20150630.tar.gz
Ahora, ejecuto los siguientes comandos:

wget https://dl.dropboxusercontent.com/u/80256631/8188eu-v7-20150630.tar.gz //ojo, corregir versión en función del kernel
tar -zxvf 8188eu-v7-20150630.tar.gz //ojo, corregir versión en función del kernel
./install.sh
sudo reboot

Tras reiniciar, con el pincho USB conectado, vuelvo a ejecutar el comando sudo lsusb, y ahora me aparece un dispositivo que antes no aparecía:

Bus 001 Device 006: ID 0bda:8179 Realtek Semiconductor Corp. 

Y si hago dmesg | more, encuentro estas líneas:

[    3.091661] usb 1-1.2: new high-speed USB device number 4 using dwc_otg
[    3.212446] usb 1-1.2: New USB device found, idVendor=0bda, idProduct=8179
[    3.238162] usb 1-1.2: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[    3.271447] usb 1-1.2: Product: 802.11n NIC
[    3.288971] usb 1-1.2: Manufacturer: Realtek
[    3.301363] usb 1-1.2: SerialNumber: 00E04C0001

Así que ahí está mi dispositivo WiFi.

Si hago sudo iwconfig, también aparace todo en orden.

Ojo. Si en algún momento actualizamos el kernel (con el comando rpi-update), tendremos que volver a descargarnos e instalar los drivers. Si encima tiene el mismo número de driver, tendremos que volver a instalarlo, haciendo lo siguiente:

wget https://dl.dropboxusercontent.com/u/80256631/8188eu-201xyyzz.tar.gz

Si quisiéramos ver un listado de redes disponibles, bastaría con hacer:

sudo iwlist wlan0 scan

Refencias

GPS GY-NEO6MV2 en la Raspberry Pi

Compré este controlador GPS con antena cerámica exenta. En la foto de la tienda venía la imagen del U-Blox:

411bRvnjcwL

Pero realmente me llegó este, con la antena incorporada:

FullSizeRender

FullSizeRender2

Quería conectarlo por USB, pero aún no me ha llegado el adaptar de USB a TTL [ahora ya me ha llegado, así que explico cómo hacerlo con el adaptador más abajo], así que lo conecto por UART.

El esquema de conexión es el siguiente:

  • 5V de la Raspberry Pi al VIN del GPS
  • GND de la Raspberry Pi al GND del GPS
  • TX de la Raspberry Pi al RX del GPS
  • RX de la Raspberry Pi al TX del GPS

Con los colores de cables que he asignado, y los pines del GPIO de la Raspberry Pi, queda así:

RPi pin 4 (5V) ----- Rojo ------- GPS VCC
RPi pin 6 (GND) ---- Azul ------- GPS GND
RPi pin 8 (TX) ----- Amarillo --- GPS RX
RPi pin 10 (RX) ---- Verde ------ GPS TX

GPIO

Esquema de pines de la Raspberry Pi

FullSizeRender4

Ahora tenemos que activar UART. Para ello editamos el fichero /boot/cmdline.txt:

sudo nano /boot/cmdline.txt

Contiene lo siguiente:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Lo dejo de la siguiente forma:

dwc_otg.lpm_enable=0 console=tty1 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

También hemos de editar /etc/inittab, comentando (poner # delante) la última línea:

#Spawn a getty on Raspberry Pi serial line
#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Reinicio la Raspberry Pi.

Ahora, instalo los programas de uso del GPS más típicos:

sudo apt-get install gpsd gpsd-clients python-gps

Arrancamos el demonio gpsd:

sudo gpsd /dev/ttyAMA0 -F /var/run/gpsd.sock

Y ejecuto el cliente GPS:

cgps -s

Y, tras esperar un rato a que encuentre las señales de los satélites necesarios, me sale lo siguiente:

┌───────────────────────────────────────────┐┌─────────────────────────────────┐
│    Time:       2015-04-18T10:06:19.000Z   ││PRN:   Elev:  Azim:  SNR:  Used: │
│    Latitude:    40.556089 N               ││   5    75    228    36      Y   │
│    Longitude:    5.673255 W               ││  13    59    314    38      Y   │
│    Altitude:   843.4 m                    ││  15    26    292    39      Y   │
│    Speed:      0.4 kph                    ││   2    10    208    22      Y   │
│    Heading:    64.1 deg (true)            ││  44    07    103    00      N   │
│    Climb:      -54.0 m/min                ││                                 │
│    Status:     3D FIX (34 secs)           ││                                 │
│    Longitude Err:   +/- 133 m             ││                                 │
│    Latitude Err:    +/- 59 m              ││                                 │
│    Altitude Err:    +/- 170 m             ││                                 │
│    Course Err:      n/a                   ││                                 │
│    Speed Err:       +/- 989 kph           ││                                 │
│    Time offset:     0.435                 ││                                 │
│    Grid Square:     IN80dk                ││                                 │
└───────────────────────────────────────────┘└─────────────────────────────────┘

¡Funciona!

Si en algún momento se “atasca”, basta con parar el proceso cgps y volverlo a arrancar:

sudo killall gpsd
sudo gpsd /dev/ttyAMA0 -F /var/run/gpsd.sock

Conexión con un adaptador USB a serie TTL

Ya me ha llegado el adaptador, así que voy a conectar ahora el GPS a la Raspberry Pi por medio de un adaptador USB a serie TTL PL2303HX, por 2€. Compré este:

FullSizeRender

FullSizeRender2

Lo conecto de la siguiente forma:

PL2303HX      GPS

3V3 --------- (No lo conecto)
TXD --------- RX
RXD --------- TX
GND --------- GND
+5V --------- VCC

Y enchufo el módulo USB a la RaspberrY Pi. Ejecuto:

ls /dev/ttyUSB*

Como tengo ahora mismo conectado un modem 3G USB, me aparecen 3 dispositivos adicionales (/dev/ttyUSB0, /dev/ttyUSB1 y /dev/ttyUSB2), junto con el nuevo /dev/ttyUSB3, que es mi GPS. Si no hubiese otros dispositivos USB conectados, seguramente aparecería como /dev/ttyUSB0.

Si hago sudo lsusb, me aparece, entre otros dispositivos:

Bus 001 Device 007: ID 067b:2303 Prolific Technology, Inc. PL2303 Serial Port

Así que ahí está mi Prolific PL2303, ok.

Miro a ver si el dispositivo está mandando alguna información (coordenadas GPS…), de forma un poco rupestre:

sudo cat /dev/ttyUSB3

Sale una ristra de lo que podría ser información geográfica, así que pinta bien. Ya sólo tengo que seguir los pasos anteriores (cuando lo conectamos por UART), y apuntar a este nuevo puerto:

sudo gpsd /dev/ttyUSB3 -F /var/run/gpsd.sock

Y ejecuto el cliente GPS:

cgps -s

¡Funciona también! Así que ya puedo decidir cómo prefiero usar el GPS, si con el adaptador a USB, y así libero los puertos UART, o a los UART.

Referencias

Whatsapp (Yowsup) en la Raspberry Pi

Es posible mandar y recibir Whastapps en una Raspberry Pi. Para ello emplearemos el programa Yowsup.

En primer lugar, instalaremos las siguientes librerías, que son necesarias para que funcione Yowsup:

sudo apt-get install python-dateutil python-pip
sudo pip install python-axolotl

(Este último tarda, pero es necesario para que funcione la última versión de yowsup).
A continuación descargamos la librería Yowsup de GitHub:

cd ~
git clone git://github.com/tgalal/yowsup.git

(Lo descargamos en la carpeta home del usuario, o donde queramos)

Registramos el número en Whatsapp

Aquí está el quid de la cuestión. Para poder enviar Whatsapp es necesario asociar nuestra “cuenta” a un número de teléfono móvil (no vale fijo). Si empleamos nuestro número de móvil no podremos usar Whatsapp en ese móvil, así que cuidado con qué número asociais. Además, tiene que ser un número en el que podáis recibir un SMS o una llamada en el momento del registro (después, nunca más…)

Hasta hace unos meses, había una compañía en España que se llamaba Fonyou que te daba una línea de teléfono “virtual” que se redirigía a tu móvil. Pero dejó de operar.

 

 

Primero hay que solicitar el código:

cd ~/yowsup
python yowsup-cli registration -p 34666354324 -C 34 -m 214 -n 07 -r sms

El número de teléfono (tras -p) debe llevar el código del país delante, pero sin 00 ni +, sólo el código. En mi caso, que vivo en España, 34. Tras -C hay que poner el código del país, nuevamente sin 00 ni + delante. Tras -m y -n hy que poner el Mobile Country Code (MCC) y el Mobile Network Code, que podemos consultar en esta página de la Wikipedia. En mi caso (Movistar) son 214 y 07, respectivamente. Tras -r podemos escoger cómo queremos recibir el código de registro, si por sms o por llamada (voice). La llamada es automática, con voz femenina y en inglés; repite el código hasta el infinito (aunque no dice que hay un guión entre medias).

Saldrá lo siguiente:

INFO:yowsup.common.http.warequest:{"status":"sent","length":6,"method":"sms","retry_after":1805}

status: sent
retry_after: 1805
length: 6
method: sms

 

Tras unos minutillos (paciencia), llegará un código, como por ejemplo: 488-970. Con este código hacemos el registro, con casi el mismo comando de antes, pero cambiando el final e introduciendo el código recibido:

python yowsup-cli registration -p 34666354324 -C 34 -m 214 -n 07 <strong>-R 488-970</strong>

Aparece lo siguiente:

pi@pigorra1 ~/yowsup $ python yowsup-cli registration -p 34666354324 -C 34 -m 214 -n 07 -R 488-970
INFO:yowsup.common.http.warequest:{"status":"ok","login":"34666354324","pw":"EVen6FsZpzprEJJI1Sk9RFvZsz8=","type":"new","expiration":1458505212,"kind":"free","price":"0,89 \u20ac","cost":"0.89","currency":"EUR","price_expiration":1429949417}

status: ok
kind: free
pw: <strong>EVen6FsZpzprEJJI1345RFvZsz8=</strong>
price: 0,89 €
price_expiration: 1429949417
currency: EUR
cost: 0.89
expiration: 1458505212
login: 34666354324
type: new

¡Ya estamos registrados, y ya debería funcionar yowsup!

Ahora vamos a crear el fichero de configuración, con la contraseña recibida:

nano /home/pi/yowsup/yowsup.config

Con el siguiente contenido:

cc=34
phone=34666354324
password=EVen6FsZpzprgdfgJI1Sk9RFvZsz8=

Guardamos y salimos (Ctrl+x, S, enter).

Mandar un whatsapp desde la línea de comando

Para mandar un whatsapp, podemos hacerlo así:

python yowsup-cli demos -c /home/pi/yowsup/yowsup.config -s 34666666666 "Hola, mundo"

Tras la -s va el número de teléfono al que queremos mandar el mwnsaje. Es imprescindible que vaya con el código del país delante, sin 00 ni +. También podemos enviar el mensaje sin pasar por el fichero de configuración, directamente así:

python yowsup-cli demos -l 34666354324:EVen6FsZpzprEJJI1Sk9RFvZsz8= -s 34666666666 "Hola, mundo"
python yowsup-cli demos -l 34666823398:SZQHAegfjH32saYXed1jrjhYEOQ= -s 34666666666 "Hola, mundo"

Mandar whatsapps con Python

En realidad, es más versatil en enviar whatsapp empleando las librerías en Python, que nos darán muchas más posibilidades, como enviar imágenes, etc. El problema es que la documentación de yowsup es muy mala, y casi es mejor estudiarse las propias librerías. Cuidado con las pruebas y errores, pues cuando Whatsapp detecta que se está haciendo uso erróneo, cancela al usuario…

Referencias

Configuración de la cámara de emergencia

Como la productora de televisión no se fía mucho prefiere (con razón) cierta redundancia y que tengamos dos cámaras grabando a la vez en el globo.

Así que he preparado una Raspberry Pi modelo A+ con una cámara y que no hace nada más que grabar desde que se arranca.

He creado un pequeño bash que graba directamente al pincho USB, montado en /media/pincho (ver explicaciones aquí). Como no va a estar conectada a internet, y la Raspberry Pi no viene con una pila que mantenga la hora del reloj, siempre que se arranque será la misma hora, y si empleo la fecha/hora para el nombre del fichero corro el riesgo de pisar anteriores grabaciones que pueda haber en ese directorio. Así que el bash cuenta primero el número de vídeos que hay en el directorio y nombra al fichero incrementando en 1 el número previo de vídeos. He llamado al fichero /home/pi/grabavid.sh:

#!/bin/bash
#Vídeo infinito en segmentos de 10 minutos, con nombre secuencial según número de ficheros:
numh264=`ls -1 /media/pincho/*.h264 2>/dev/null | wc -l`
raspivid -t 0 -sg 600000 -w 1920 -h 1080 -fps 30 -o /media/pincho/vidPiGlobo1b$((numh264+1))%04d.h264

Y para que se ponga en marcha este script al arrancar, he añadido lo siguiente a /etc/rc.local:

sudo nohup sh /home/pi/grabavid.sh >/dev/null 2>&1 &

Arrancando por primera vez la Raspberry Pi

En este post he explicado cómo instalar el sistema operativo Raspbian en una tarjeta SD. Ahora vamos a introducir esa tarjeta en la Raspberry Pi y arrancarla por primera vez, para dejar el sistema bien configurado y listo para usarse.

La primera vez que arranquemos la Raspberry Pi (o mejor dicho, la tarjeta del sistema operativo) es necesario que esté conectada a un monitor y a un teclado, pues SSH no está activado por defecto y no podremos acceder a ella desde otro ordenador.

Nos sale la siguiente pantalla (siempre podremos volver a esta pantalla ejecutando el comando sudo raspi-config):

Captura de pantalla 2015-04-05 a las 10.52.34

Lo primero, expandimos el disco, pues al instalar la imagen del sistema operativo seguramente su tamaño no era el mismo que el de nuestra tarjeta SD.

Captura de pantalla 2015-04-05 a las 10.54.14

Cambiamos la contraseña. Por defecto, el usuario es pi y la contraseña raspberry.

Captura de pantalla 2015-04-05 a las 10.54.47

Captura de pantalla 2015-04-05 a las 10.55.09

Captura de pantalla 2015-04-05 a las 10.55.52

No voy a usar el Desktop ni Scratch, así que paso directamente a las opciones de internacionalización.

Captura de pantalla 2015-04-05 a las 10.56.14

Empiezo con el idioma y la región.

Captura de pantalla 2015-04-05 a las 10.56.45

De la lista de posibilidades, bajo hasta el Locale que quiero, que en mi caso es español de España, con codificación UTF-8 “es_ES.UTF-8 UTF-8”. Para seleccionar este locale, pulso la barra espaciadora cuando el cursor esté encima. Mantengo marcado el inglés como estaba en_GB.UTF-8 UTF-8, aunque luego seleccionaré el español como por defecto. Con el tabulador me desplazo hasta y salgo de esta pantalla.

Captura de pantalla 2015-04-05 a las 11.00.37

Selcciono como configuración regional predeterminada el español (tardará unos segundos en generar los locales):

Captura de pantalla 2015-04-05 a las 11.02.13

Vuelvo a las opciones de internacionalización y cambio la franja horaria (Europa – Madrid).

Captura de pantalla 2015-04-05 a las 11.03.25

Captura de pantalla 2015-04-05 a las 11.04.07

Captura de pantalla 2015-04-05 a las 11.04.33

Vuelvo por última vez a las opciones de internacionalización y selecciono mi teclado (Generic 105-key (Intl) PC – Other – Spanish – Spanish – The default for the keyboard layout – No compose key – No).

Captura de pantalla 2015-04-05 a las 11.05.11

Activo la cámara, pues voy a emplearla en esta Raspberry Pi.

Captura de pantalla 2015-04-05 a las 11.06.42

Captura de pantalla 2015-04-05 a las 11.07.01

No añado al Rastrack, ni hago overcloking (por el momento).

Y nos queda el paso más importante: vamos a Advanced Options y activo SSH:

Captura de pantalla 2015-04-05 a las 11.07.39

Captura de pantalla 2015-04-05 a las 11.08.04

Captura de pantalla 2015-04-05 a las 11.08.26

Y hemos acabado. Reinicio y ya está lista la Raspberry Pi para acceder a ella por SSH.

Tras el reinicio, lo primero que hacemos es actualizar todo (esto puede llevar un buen rato, según cómo de reciente sea la imagen del sistema operativo, y la cantidad de mejoras que haya habido desde su publicación):

sudo apt-get update
sudo apt-get upgrade

Instalar Raspbian en la Raspberry Pi

Raspbian es un sistema operativo libre basado en Debian (Linux), y es quizás la distribución más utilizada en la Raspberry Pi.

Lo primero que tenemos que hacer es descargarnos la imagen, para montarla sobre una tarjeta SD que será la que aloje el sistema operativo. La podemos descargar de la Raspberry Pi Foundation. Allí vienen varios tutoriales sobre cómo montar la imagen sobre la tarjeta SD y luego configurar la Raspberry Pi.

En mi caso, estoy trabajando ahora mismo en un Mac, y los pasos que sigo son:

Descargo la imagen aquí. Una vez se termine la descarga, descomprimo el fichero .zip.

A continuación, inserto la tarjeta SD en el lector de tarjetas del Mac (ojo, se perderá toda la información que contenga), y ejecuto el siguiente comando en una terminal, para ver dónde está:

diskutil list

Aparece, entre otras cosas, lo siguiente:

<strong>/dev/disk2</strong>
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:     FDisk_partition_scheme                        *31.9 GB    disk2
   1:             Windows_FAT_32 NO NAME                 31.9 GB    disk2s1

Es decir, que mi tarjeta está siendo asignada a /dev/disk2. Por cierto que es una tarjeta de 32GB; generalmente bastará con mucho menos, pero necesito esa capacidad para otros propósitos. También es importante la velocidad de la tarjeta. Si es de Clase 10, mejor.

Desmonto la unidad asociada a la tarjeta:

diskutil unmountDisk /dev/disk2

Y ahora, voya a cargar la imagen sobre la tarjeta. Previamente, en la consola del Mac me habré situado en la carpeta donde tengo la imagen descomprimida, o cambiaré la ruta según sea necesario:

sudo dd bs=1m if=2015-02-16-raspbian-wheezy.img of=/dev/disk2

Tras un buen rato esperando (en mi caso, unos 20 minutos), se acaba de copiar. Y para acabar:

sudo diskutil eject /dev/disk2

Retiro la tarjeta y ¡ya está lista para meterla en la Raspberry Pi y hacer el primer arranque!

Montar un pincho USB permanentemente en la Raspberry Pi

Hacer que la Raspberry Pi reconozca una memoria USB y la monte siempre que se reinicie es sencillo. Hay que seguir los siguientes pasos.

Lo primero es localizar el pincho. Lo enchufamos a la Raspberry Pi y ejecutamos el siguiente comando:

sudo fdisk -l

 

Aparecerán todos los dispositivos conectados a la Raspberry Pi. Buscamos el nuestro. En mi caso, es /dev/sda1, y aparece con un formato tipo VFAT (FAT32):

Disk /dev/sda: 62.5 GB, 62518853632 bytes
255 heads, 63 sectors/track, 7600 cylinders, total 122107136 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1              64   122107135    61053536    c  W95 FAT32 (LBA)

Ahora tenemos que crear el punto de montaje del pincho, el directorio que queremos que apunte al pincho. En mi caso, lo haré en /media/pincho:

sudo mkdir /media/pincho

 
Al ser el tipo de formato FAT, que es automáticamente reconocido por Raspbian, con hacer sudo mount /dev/sdc1 /media/pincho, es suficiente para montar el pincho. Si estuviese en exFAT (me ha pasado), Raspbian no lo reconoce por defecto, por lo que tenemos que instalar el siguiente driver:

sudo apt-get install exfat-fuse

 
Y ahora ya sí podríamos montar el pincho:

sudo mount /dev/sda1 /media/pincho

 
Ya está montado, y podemos acceder al pincho en la carpeta /media/pincho y escribir y leer en él. Pero si reiniciamos la Raspberry Pi ya no aparecerá y tendremos que volver a montarlo manualmente. Si queremos que se monte automáticamente en cada reinicio, tenemos que hacer lo siguiente.

Primero hay que averiguar el UUID del pincho:

sudo blkid

 
Me aparece, entre otras cosas:

/dev/sda1: LABEL="MINIPINCHO" UUID="<strong>4A8B-0102</strong>" TYPE="vfat" 

 
Y ahora edito /etc/fstab para que monte el pincho que tiene ese UUID, ejecutando sudo nano /etc/fstab y añadiendo una línea que ponga lo siguiente:

UUID=4A8B-0102 /media/pincho vfat defaults,auto,users,rw,uid=pi,gid=pi 0 0

 
Ahora puedo reiniciar y ver si está todo en orden, o, mejor aún, ejecuto sudo mount -a, que carga el fichero /etc/fstab como si fuese un reinicio.

Mandar y recibir SMS con Gammu en la Raspberry Pi

Enviar un SMS es muy sencillo, pero no quiero engañar a nadie: configurar el modem de forma que la Raspberry Pi lo reconozca puede dar mucha guerra, y ya lo he explicado en este otro post.

Antes de nada, también hay que aclarar que para poder mandar SMS desde la Raspberry Pi según el procedimiento que voy a contar necesitamos tener conectado a la Raspberry Pi un modem GSM (cualquier modem 3G USB actual) con una tarjeta SIM con su correspondiente contrato.

Modem 3G USB Huawei E173u-2

Modem 3G USB Huawei E173u-2

Modem 3G USB Huawei E173u-2

Modem 3G USB Huawei E173u-2

Mandar SMS

Lo primero, una vez que nuestra Raspberry Pi reconoce el modem como tal (ver, como he dicho antes, este otro post en el que lo explico), es instalarnos el programa Gammu:

sudo apt-get install gammu

Ejecuto dmesg | grep tty, y me sale al final:

[ 3101.026510] usb 1-1.4: GSM modem (1-port) converter now attached to ttyUSB0
[ 3101.047379] usb 1-1.4: GSM modem (1-port) converter now attached to ttyUSB1
[ 3101.050728] usb 1-1.4: GSM modem (1-port) converter now attached to ttyUSB2
[ 3101.054227] usb 1-1.4: GSM modem (1-port) converter now attached to ttyUSB3

Apunto el primer puerto (ttyUSB0), que será el puerto que introduciré en la configuración:

sudo gammu-config 
Captura de pantalla 2015-03-21 a las 19.32.41

Configuración de Gammu

No cambio ninguna cosa más que el puerto y listo. El asistente anterior lo que hace es generar el fichero /root/.gammurc, que podremos modificar si queremos más adelante. En mi caso, he hecho pruebas y puedo enviar SMS desde ttyUSB0 y ttyUSB2, pero no del 1 y 3.

Ahora ejecuto el comando sudo gammu --identify para ver que todo está bien, y obtengo:

Dispositivo          : /dev/ttyUSB0
Fabricante           : Huawei
Modelo               : E173 (E173)
Firmware             : 11.126.15.00.18
IMEI                 : 342341311668563
IMSI SIM             : 134546457667592

(he alterado el IMEI y el IMSI SIM).

Así que puedo probar a enviar mi primer SMS:

echo "Hola mundo" | sudo gammu sendsms TEXT 650696969

¡Funciona! Tarda unos 9 segundos desde que se da al enter hasta que llega el SMS al móvil.

Mandar un fichero de texto, o varias líneas

 

También podemos enviar ficheros, siempre con la precaución de la longitud de los mismos.

 

Mandar SMS empleando Python

sudo apt-get install python-gammu

 

 

Recibir SMS

Instalo el programa gammu-smsd:

sudo apt-get install gammu-smsd

Creo el fichero de configuración:

sudo nano /etc/gammu-smsdrc 

Edito algunas partes:

port = /dev/ttyUSB0
connection = at

(No hace falta poner la velocidad at19200 o at152000, basta con at).

Hay muchas más opciones de configuración y qué hacer con los mensajes que llegan, bases de datos MySQL, etc. (ver el manual), pero a mí lo que me interesa es poder ejecutar un comando al recibir un determinao SMS.

Si queremos que se ejecute un comando, añadimos al final:

RunOnReceive = /home/pi/gammu/recibeSMS.sh

(apuntando a la ruta donde tengamos el bash que queremos que se ejecute al recibir el SMS, en mi caso en /home/pi/gammu/recibeSMS.sh. Previamente hay que dar permisos de ejecución a ese fichero: chmod + x /home/pi/gammu/recibeSMS.sh).

Y el fichero /home/pi/gammu/recibeSMS.sh contiene lo que queremos que se ejecute. Por ejemplo:

#!/bin/sh
from=$SMS_1_NUMBER
echo "¡Hola, mundo!" | sudo gammu sendsms TEXT "$from"

O que haga algo determinado, en función del contenido del mensaje:

#!/bin/sh
from=$SMS_1_NUMBER
message=$SMS_1_TEXT
reply=""
 
if test "$message" = "Ping"; then
    reply="Pong!"
else
    reply="Y U NO PLAY PING PONG?"
fi
 
echo "$reply" | sudo gammu sendsms TEXT "$from"

En esta página del manual se explican más acciones.

Para ejecutar el demonio y que esté a la escucha de SMS:

sudo gammu-smsd

(Podremos llamar a este demonio en el arranque, añadiéndolo al /etc/rc.local).

Enviar MMS

First you need to create MMS data (SMIL). Then upload them somewhere
where phone can download it over GPRS
(http://somewehere.something/location in next example). Now you can
send MMS indicator message to phone which will then download the
message:
gammu —sendsms MMSINDICATOR +123456789 \
http://somewehere.something/location \
“Message from Gammu” \
“Gammu program”

MMSETTINGS settings can be used to send MMS settings from Gammu backup
format (you can generate it by gammu –backup).

Referencias