.

Controlemos entradas y salidas de una Raspberry PI en Python – Parte 1

inventable 13 comentarios

En el proyecto precedente, "Controlando leds con una Raspberry PI", hemos visto como trabajar
con las entradas y las salidas de una Raspberry PI a través de un pequeño programa de tipo
terminal. Esta vez veremos un programa con interfaz gráfica, que permite de activar 3 relés y ver
el estado de 3 entradas digitales.
Como en el caso anterior este proyecto es mas bien un ejemplo de integración entre electrónica y
software, pueden estudiarlo para conocer la tecnología empleada, modificarlo o usarlo como
inspiración para desarrollar proyectos más complejos.
Si necesitan instalar desde 0 il sistema operativo en vuestra Raspberry PI les aconsejo de leer
nuevamente mi artículo anterior "Controlando leds con una Raspberry PI" donde explico en modo
detallado como bajar el software NOOBS, instalarlo y actualizarlo.

Antes de proseguir les cuento que actualmente estoy usando una Raspberry PI modelo 3, sin
necesidad de conectar un monitor, teclado o mouse porque la veo y la controlo en modo remoto a
través de mi red WiFi con el programa VNC. Es muy cómodo de usar y además es gratis. En la
Raspberry, el VNC está ya instalado mientras que en el PC hay que bajarlo e instalarlo. Una vez
instalado y activado en la Raspberry, les aconsejo de ir a la configuración del modem / router WiFi
y de dar una dirección IP fija a la Raspberry (en mi caso por ejemplo puse 192.168.0.90) en modo
tal que el DHCP asigne siempre la misma dirección a la Raspberry y no tener que buscar el IP cada
vez que la encendemos.

Volviendo al proyecto, hacer un programa con interfaz gráfica (GUI: graphical user interface) tiene
su complejidad. Para lograrlo conviene apoyarse a una librería software ya existente. Existen
librerías gráficas de muchos tipos pero al final de cuentas, todas ellas sirven para crear las clásicas
ventanas que estamos acostumbrados a ver y a usar en las pantallas de nuestros ordenadores.
Hay librerías que están proyectadas para funcionar con un determinado sistema operativo mientras
que otras pueden funcionar con más de uno de ellos. Adoptar una librería en lugar de otra depende
de varios factores como por ejemplo el lenguaje de programación que queremos usar, el sistema
operativo, si están ya incorporadas en ambientes de desarrollo visual, la complejidad y la potencia
que necesitamos, la "portabilidad del código" y otros factores.

Si usamos Python con Linux, que es el sistema operativo de la Raspberry PI, la elección se
simplifica bastante: las librerías más populares son PyQt (derivada de QT), PyGTK (derivada de
GTK+), wxPython (derivada de wxWidgets) e Tkinter (derivada de Tcl/Tk). Esta última es la
menos sofisticada pero al mismo tiempo la más liviana y fácil de usar. Tkinter funciona con Linux,
iOS y también con Windows. Además, se encuentra ya incorporada en la distribución de Python, sin
necesidad de ser instalada aparte. Por estos motivos, la adoptaremos para nuestro primer programa
gráfico.
El hardware

Empecemos con el hardware: 3 botones y 3 relés. Para los botones usaremos el mismo circuito del
proyecto anterior pero esta vez las resistencias estarán conectadas a masa mientras que los
pulsadores a positivo como podemos ver en la figura. De esta forma la lógica será positiva: en
reposo las entradas de la Raspberry se encuentran a masa y cuando activamos los botones, pasan a
positivo. La lógica de la Raspberry PI es de 3,3V por lo tanto nuestro positivo no debe superar esta
tensión. El modo más simple es el de usar los 3,3V ya disponibles en el pin 17 del conector
principal de la Raspberry.
Para los relés necesitamos una alimentación separada cuya tensión dependerá de la bobina de los
relés. Yo he usado relés de 12V. Para activarlos podemos usar transistores comunes como explico
detalladamente en mi artículo "controlar un relé con un transistor" o con un circuito integrado
ULN2003 que consiste en 7 drivers hechos con transistores en configuración Darlington y del cual
escribiré próximamente un artículo.
Ambas soluciones son correctas pero con el ULN2003 el circuito es más simple de hacer,
especialmente en el caso de necesitar de muchos canales de salida. El ULN2003 lleva ya a bordo los
diodos de protección para la activación de los relés por lo que no es necesario instalarlos
externamente, en paralelo con las bobinas. Debemos solamente conectar el pin 9 del integrado al
positivo que alimenta los relés.
Para escribir el programa usaremos un editor de texto pensado para Python, que se llama Python3
IDLE y que ya se encuentra instalado en nuestra Raspberry PI. Podemos abrirlo desde:
menu principal -> Programming -> Python 3 (IDLE) como podemos ver en la figura siguiente.
Existe mucha documentación on-line sobre IDLE por lo tanto me limitaré solo a los elementos
necesarios para escribir y hacer funcionar el programa. Si lo hemos abierto para verlo, ahora
podemos cerrarlo porque para llegar a él usaremos otro modo que a continuación describo.

Preparando el ambiente de trabajo

Cuando abrimos el file manager de Linux (el tercer icono en alto de la pantalla, con el diseño de una
carpeta amarilla) el sistema operativo nos muestra el contenido de la carpeta del usuario principal
que es "pi". La primera cosa que haremos es la de crear una carpeta llamada "Inventable" donde
pondremos los files de trabajo que iremos desarrollando ahora y en el futuro. Para ello abrimos el
menú:
File - > Create News -> Folder
Nos aparecerá una ventana de dialogo en la cual escribiremos "Inventable" y después hacemos
click sobre "OK".

Al interno de la carpeta "pi" aparecerá la nueva carpeta llamada "Inventable". Hacemos doble
click sobre ella para ver su contenido. Estará vacía. Con el mismo método anterior, dentro de
"Inventable" podemos crear la carpeta "in_out_gui". En las figuras de este artículo verán otras
carpetas que he creado y que servirán para otros proyectos.

Por ahora no sirven, usaremos solo la carpeta llamada "in_out_gui". Hacemos doble click sobre
"in_out_gui" para posicionarnos dentro de ella y después, apretamos el botón derecho del mouse,
se abrirá un menú contextual en el cual elegiremos:
Create New -> Empty File.
A este nuevo file lo llamaremos "in_out_gui_v1.py".

Haciendo doble click sobre él se abrirá automáticamente el editor IDLE que nos mostrará
lógicamente, un documento vacío porque todavía no hemos escrito nada. El sistema operativo eligió
automáticamente IDLE como editor porque nuestro archivo tiene la extensión "py", típica de los
programas Python.
Ahora escribimos el siguiente texto en el file vacío para verificar que los componentes software
necesarios para nuestro proyecto estén correctamente instalados (la librería gráfica Tkinter y la
librería de gestión de las entradas y las salidas RPi.GPIO).
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import RPi.GPIO as io
import tkinter as tk
from tkinter import ttk

Una vez hecho esto probamos a ejecutarlo desde el menú RUN -> Run Module del editor o
directamente usando la tecla de función F5.
Si en la pantalla nos aparece el mensaje de la figura, sin indicaciones de error, quiere decir que todo
está funcionando bien y podemos escribir nuestro programa.

A continuación les muestro la primera versión completa del programa y sucesivamente explicaré
cada parte de él. Ustedes pueden escribirlo todo a mano (es un buen ejercicio para familiarizarse
con el lenguaje) o copiarlo y pegarlo en el documento vacío.
Para mayor claridad, he usado instrucciones muy simples y evitando técnicas de programación
avanzadas (como por ejemplo objetos). Les recuerdo que Python divide lógicamente los bloques de
un programa con dos puntos seguidos por la identación del código (sangría) y que es mejor que
esta esté hecha con una cantidad igual de espacios (por norma 4 espacios). No mezclemos espacios
y tabulaciones en el mismo programa porque nos dará un error.

Primera versión del programa

1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3 """-------------------------------------------------------------------------------
4 Project: In/Out with GUI (graphical user interface)
5 File: in_out_gui_v1.py
6 Version: 1.0
7 Purpose: Controlar 3 entradas y 3 salidas
8 Author: Gabriel Rapetti / Inventable.eu
9 Created: 21/10/2017
10 Copyright: Creative Commons (CC) BY-NC-SA
11 -------------------------------------------------------------------------------
12 """
13 import RPi.GPIO as io # Importa libreria de I/O (entradas / salidas)
14 import tkinter as tk # Importa la libreria grafica (GUI)
15 from tkinter import ttk
16
17 # Configuracion de las entradas y las salidas del micro
18 # -----------------------------------------------------
19 in1 = 23 # en las variables in1, in2, in3
20 in2 = 24 # memoriza los números de los puertos
21 in3 = 25 # de entrada
22
23 out1 = 17 # en las variables out1, out2 y out3
24 out2 = 27 # memoriza los números de los puertos
25 out3 = 22 # de salida
26
27 io.setmode(io.BCM) # modo in/out pin del micro
28 io.setwarnings(False) # no señala advertencias de pin ya usados
29
30 io.setup(in1,io.IN) # configura en el micro las entradas
31 io.setup(in2,io.IN)
32 io.setup(in3,io.IN)
33
34 io.setup(out1,io.OUT) # configura en el micro las salidas
35 io.setup(out2,io.OUT)
36 io.setup(out3,io.OUT)
37
38 # Funcion de lectura de las entradas
39 # -----------------------------------
40 def check_inputs():
41 if io.input(in1):
42 label1.config(bg = '#FD4') # si la entrada 1 es a 1 enciende la label
43 else:
44 label1.config(bg = '#BBB') # si no lo es la apaga
45
46 if io.input(in2):
47 label2.config(bg = '#FD4') # si la entrada 2 es a 1 enciende la labe2
48 else:
49 label2.config(bg = '#BBB') # si no lo es la apaga
50
51 if io.input(in3):
52 label3.config(bg = '#FD4') # si la entrada 1 es a 1 enciende la labe3
53 else:
54 label3.config(bg = '#BBB') # si no lo es la apaga
55
56 root.after(50, check_inputs) # activa un timer de 50mSeg.
57 # para retornar a esta función
58
59 # Funciones de las salidas activadas por los pulsadores
60 # -----------------------------------------------------
61 def on_off1():
62 if push_button1.cget("bg")=='#FD4': # si el botón 1 está encendido
63 push_button1.config(bg = '#DDD') # lo apaga y
64 io.output(out1,0) # pone a 0 el pin de salida
65 else:
66 push_button1.config(bg = '#FD4') # de otro modo lo enciende y
67 io.output(out1,1) # pone a 1 el pin de salida
68
69 def on_off2():
70 if push_button2.cget("bg")=='#FD4': # si el botón 2 está encendido
71 push_button2.config(bg = '#DDD') # lo apaga y
72 io.output(out2,0) # pone a 0 el pin de salida
73 else:
74 push_button2.config(bg = '#FD4') # de otro modo lo enciende y
75 io.output(out2,1)
76
77 def on_off3():
78 if push_button3.cget("bg")=='#FD4': # si el botón 3 está encendido
79 push_button3.config(bg = '#DDD') # lo apaga y
80 io.output(out3,0) # pone a 0 el pin de salida
81 else:
82 push_button3.config(bg = '#FD4') # de otro modo lo enciende y
83 io.output(out3,1) # pone a 1 el pin de salida
84
85 # Creación de la ventana principal
86 # -----------------------------------------------------
87
88 root = tk.Tk() # Crea una instancia de la librería
89 # Tkinter con el nombre "root"
90 root.title("In/Out Panel") # Título del programa
91 root.geometry("270x110") # Dimensiones de la ventana
92
93 # Creación de los indicadores para las entradas (labels)
94 # -----------------------------------------------------
95
96 label1 = tk.Label(root, text = "IN 1", width = 9, bg = '#CCC')
97 label1.place(x = 20, y = 15)
98
99 label2 = tk.Label(root, text = "IN 2", width = 9, bg = '#CCC')
100 label2.place(x = 100, y = 15)
101
102 label3 = tk.Label(root, text = "IN 3", width = 9, bg = '#CCC')
103 label3.place(x = 180, y = 15)
104
105 # Creación de los botones (buttons)
106 # -----------------------------------------------------
107 push_button1 = tk.Button(root, text = "OUT 1", width = 6, command = on_off1)
108 push_button1.place(x = 20, y = 60)
109
110 push_button2 = tk.Button(root, text = "OUT 2", width = 6, command = on_off2)
111 push_button2.place(x = 100, y = 60)
112
113 push_button3 = tk.Button(root, text = "OUT 3", width = 6, command = on_off3)
114 push_button3.place(x = 180, y = 60)
115
116 # Ciclo principal del programa
117 # -----------------------------
118
119 check_inputs() # Llama por primera vez la función que lee las entradas
120 root.mainloop() # Loop principal
121
122 # Fin del Programa

Para probar el programa apretamos la tecla F5 (RUN). Debería aparecer una ventana como la que
vemos en la figura siguiente:

Haciendo click con el mouse sobre los botones de la ventana podemos activar o desactivar los relés
mientras que accionando los pulsadores físicos veremos el cambio de estado de las entradas
respectivas en el programa.

Descripción de la primera versión del programa

Ahora, veamos el programa por partes seguido por una descripción:
#!/usr/bin/env python
# -*- coding: utf-8 -*-

Estos dos renglones sirven para decirle a linux que el file en cuestión es un programa Python
(también llamado script) y que debe ser ejecutado a través del interprete Python. El segundo renglón
dice al interprete de codificar el programa en formato UTF-8 (Unicode Transformation Format, 8
bit).
"""----------------------------------------------------------------------------
Project: In/Out with GUI (graphical user interface)
File: in_out_gui_v1.py
Version: 1.0
Purpose: Controlar 3 entradas y 3 salidas
Author: Gabriel Rapetti / Inventable.eu
Created: 21/10/2017
Copyright: Creative Commons (CC) BY-NC-SA
-------------------------------------------------------------------------------
"""

Los renglones entre grupos de tres comillas (""") son una zona para escribir comentarios y serán
ignorados durante la ejecución del programa por parte del interprete Python. También se pueden
hacer comentarios poniendo el símbolo # al inicio de cada renglón pero la comillas permiten de
crear comentarios que después generarán automáticamente documentación técnica del proyecto. Por
este motivo se usan en las descripciones más importantes del programa. Yo generalmente, creo un
espacio de presentación inicial donde agrego datos generales del proyecto (nombre, autor, fecha,
etc.).
import RPi.GPIO as io
import tkinter as tk
from tkinter import ttk

Estos tres renglones importan las librerías que usaremos para nuestro programa: RPi.GPIO para las
entradas y salidas de las Raspberry, Tkinter para la parte gráfica y ttk que es una extensión de
Tkinter.
in1 = 23
in2 = 24
in3 = 25

out1 = 17
out2 = 27
out3 = 22

io.setmode(io.BCM)
io.setwarnings(False)

io.setup(in1,io.IN)
io.setup(in2,io.IN)
io.setup(in3,io.IN)

io.setup(out1,io.OUT)
io.setup(out2,io.OUT)
io.setup(out3,io.OUT)

Esta parte del programa configura los puertos 23, 24 y 25 del microcontrolador como entradas y los
puertos 17, 27 y 22 como salidas.
def check_inputs():
if io.input(in1):
label1.config(bg = '#FD4')
else:
label1.config(bg = '#BBB')

if io.input(in2):
label2.config(bg = '#FD4')
else:
label2.config(bg = '#BBB')

if io.input(in3):
label3.config(bg = '#FD4')
 else:
label3.config(bg = '#BBB')

root.after(50, check_inputs)

Aquí tenemos una función de Python. Se reconoce por la palabra clave "def" seguida por el
nombre de la función y una zona entre paréntesis donde poder pasar parámetros. En este caso no
hay nada entre paréntesis porque no es necesario pasar algún parámetro. Esta función controla las
entradas in1, in2, in3 del micro (que son variables asignadas a los puertos 23, 24 y 25 del micro) y
en base a su estado lógico (alto o bajo) cambia el color de fondo de las label1, label2 y label3. Las
labels son rectángulos con un texto dentro. Pueden ser de color o trasparentes. Serán creadas más
adelante. El último renglón (root.after) dice al programa de retornar a esta función después de 50
milisegundos ("50" pasado como parámetro y que se calcula en milisegundos) . De esta forma se
logra obtener un control periódico de las entradas.
def on_off1():
if push_button1.cget("bg")=='#FD4':
push_button1.config(bg = '#DDD')
io.output(out1,0)
else:
push_button1.config(bg = '#FD4')
io.output(out1,1)

def on_off2():
if push_button2.cget("bg")=='#FD4':
push_button2.config(bg = '#DDD')
io.output(out2,0)
else:
push_button2.config(bg = '#FD4')
io.output(out2,1)

def on_off3():
if push_button3.cget("bg")=='#FD4':
push_button3.config(bg = '#DDD')
io.output(out3,0)
else:
push_button3.config(bg = '#FD4')
io.output(out3,1)

Estas son tres funciones casi iguales, con la diferencia que cada una de ellas trabaja con cada botón
que activan los relés. Son llamadas automáticamente cuando apretamos uno de los botones
diseñados en la pantalla. Como tenemos un solo botón para activar y desactivar cada relé, este
trabaja como un flip flop de tipo "T" (o toggle), es decir, si el relé está activado, cuando lo
tocamos lo desactivamos y viceversa. Para obtener este resultado, el programa lee el color del
botón, si este es '#FD4' (encendido) lo apaga poniendo el color '#DDD' (apagado) y al mismo
tiempo cambia el estado lógico de la salida, por ejemplo io.output(out1,0). Si por el contrario está
apagado (color = '#DDD') lo enciende. Existen diferentes modos de trabajar con los colores en
Python, en este programa uso la notación hexadecimal simplificada donde cada dígito es uno de
los colores RGB, por lo tanto '#000' es negro y '#FFF' es blanco.
root = tk.Tk()
root.title("In/Out Panel")
root.geometry("270x110")

label1 = tk.Label(root, text = "IN 1", width = 9, bg = '#BBB')

label1.place(x = 20, y = 15)
label2 = tk.Label(root, text = "IN 2", width = 9, bg = '#BBB')
label2.place(x = 100, y = 15)

label3 = tk.Label(root, text = "IN 3", width = 9, bg = '#BBB')

label3.place(x = 180, y = 15)

En esta parte creamos la ventana principal de nuestro programa que mide 270 pixel por 110 pixel y
las tres labels que servirán para ver el estado de las entradas. El color inicial de ellas será
"desactivado" (bg = '#BBB'). La sigla "bg" significa background color.
push_button1 = tk.Button(root, text = "OUT 1", width = 6, command = on_off1)
push_button1.place(x = 20, y = 60)

push_button2 = tk.Button(root, text = "OUT 2", width = 6, command = on_off2)

push_button2.place(x = 100, y = 60)

push_button3 = tk.Button(root, text = "OUT 3", width = 6, command = on_off3)

push_button3.place(x = 180, y = 60)

Aquí creamos los botones que activarán los relés. Observen el comando "command = on_off" que
sirve para hacer la llamada automática cuando hacemos "click" con el mouse a una de las tres
funciones "on_off" que hemos visto antes y que gestionan los botones.
check_inputs()
root.mainloop()

El primer renglón es una llamada a la función chek_inputs() que lee las entradas por primera vez,
después no será más necesario llamarla desde aquí porque la misma función de lectura de las
entradas se llamará a si misma.
Para terminar root.mainloop() es el ciclo principal del programa. Este lo mantiene vivo,
gestionando los eventos que llegan a él (por ejemplo las acciones del mouse o el timer para leer las
entradas). El ciclo se interrumpe definitivamente cuando hacemos click sobre la cruz, en alto de
nuestra ventana, terminando el programa.
En la segunda parte de este artículo veremos una nueva versión del programa, más flexible y
modular, gracias al uso de matrices y de ciclos "for".
Hasta la próxima!!
Gabriel

Artículos relacionados:
- Controlemos entradas y salidas de una raspberry pi en python - parte 2
- Controlando leds con una Raspberry PI
- Como controlar un relé con un transistor
Linphone and Raspberry Pi
Last modified by Nicolas Michon on 2019/07/19 14:44

Contents
 Using the raspberry pi for video monitoring
 Prequisites
 Compiling linphone on the rasberry pi
 Configuration
 Starting linphonec
 Automatic start at boot
 Common hardware problems

Using the raspberry pi for video monitoring

The Raspberry PI is a good hardware for making a simple video monitoring device, such as
watching at any time what's happening at home, if cats have enough to eat, chicken safe from fox
attacks, or simply see at distance what's the weather like. The linphone console tools (linphonec
and linphone-daemon) can be used to automatically accept a SIP call with video, so that it becomes
possible from Linphone android or iOS app to call home at any time.
From a hardware standpoint, a raspberry pi2 is a minimum for a decent image quality. Indeed,
video software encoding is a cpu consuming task that a pi 1 can hardly achieve as it doesn't have the
NEON (multimedia) instruction set.
The PI's camera has excellent quality, however plugging a USB camera can be more interesting as it
will provide sound recording thanks to its integrated microphone, which the raspberry doesn't have.
An ethernet connection is preferred, though wifi would work decently for video transmission as
long as the raspberry is not too far from the wifi router.
Displaying the video received by the raspberry is out of this article's scope : we will just focus on
the capture, sound and video, as well as the transmission via SIP to another SIP phone.
The following section explains how to setup the video monitoring on the raspberry pi by
compilation on the raspberry to use linphone console tools directly

Prequisites
We recommend to use Raspbian, as a base installation to run linphone.
Since linphone heavily makes uses of dual-stack (ipv6 and ipv4) sockets, it is required to enable
ipv6 on the raspberry by doing (as root):

echo ipv6 >> /etc/modules

And reboot.
To be clear, there is absolutely no need to have an IPv6 connection, the concern is only to enable the
IPv6 APIs of the kernel (which are compatible with IPv4 operation of course).

Compiling linphone on the rasberry pi

This procedure is for using the linphone console tools (linphonec, linphonecsh or linphone-daemon)
on the raspberry pi.
It assumes that the raspberry pi is installed with a Raspbian image.
 Install build dependencies from raspbian repositories
sudo apt-get install cmake automake autoconf libtool intltool yasm libasound2-dev libpulse-dev
libv4l-dev nasm git libglew-dev
 Clone the linphone-desktop git repository. This repository comprises the linphone source
code plus all required dependencies, with an overall build script that builds everything in
order.
git clone git://git.linphone.org/linphone-desktop.git --recursive
 Setup compilation options for the whole linphone-desktop project. The line below sets
options for a minimal linphone build, without graphical user interface.
cd linphone-desktop
./prepare.py no-ui -DENABLE_OPENH264=ON -DENABLE_WEBRTC_AEC=OFF -
DENABLE_UNIT_TESTS=OFF -DENABLE_MKV=OFF -DENABLE_FFMPEG=ON -
DENABLE_CXX_WRAPPER=OFF -DENABLE_NON_FREE_CODECS=ON -
DENABLE_VCARD=OFF -DENABLE_BV16=OFF -DENABLE_V4L=OFF
 Now proceed with the compilation. This step may take around half an hour and will warm
the raspberry !
make -j4
 Once completed, the output executables are in OUTPUT/no-ui/bin. The intermediate
compilation products are all located in the WORK directory, that you can safely remove.
Should any compilation problem happen, in order to restart the compilation from the
beginning, removing the WORK directory is sufficient.
Now the software is ready to be used !

Configuration
First run linphonec once in order to configure your SIP account, so that you can place calls to your
raspberry from another place (typically the linphone app on android or iOS!). We recommend to use
our free sip.linphone.org service, on which accounts can be created using this online form.

cd OUTPUT/no-ui/bin

./linphonec
[.....]

linphonec> proxy add

[…enter sip account configuration.

We recommend to set proxy address to <sip:sip.linphone.org;transport=tls>
Once done, you should be prompted for your sip account password, and then it should indicate that
it is successfully registered. ]
quit

You may also, within the linphonec command prompt, set the sound card to use for capturing sound.
The raspberry-pi has no microphone, but if your plan is to plug a USB camera onto the raspberry
pi, it probably has a built-in microphone. To tell linphonec to use the microphone from the usb
camera, use the "soundcard list" and "soundcard use" commands to select the sound card index to
use.
Now open ~/.linphonerc file with an editor (vim, nano...) in order to tweak a few things:
 In section [sound], set

echocancellation=0

Indeed, echo cancellation is not needed, our raspberry pi has no speaker. No need to spend cpu
cycles on this.
 In section [video], set vga video size to achieve decent quality, compatible with the pi's
processing capabilities:

size=vga

720p is also possible but the pi2 cpu is a bit too slow for this image format with VP8 codec. svga
tends to work not so bad as well.
 Turn on ICE, in section [net] section:

stun_server=stun.linphone.org
firewall_policy=3

Starting linphonec
You can then launch linphonec in background mode in with auto-answer mode. We assume the
current directory is already in the OUTPUT/no-ui/bin directory.
export PATH=$PATH:`pwd`
linphonecsh init -a -C -c ~/.linphonerc -d 6 -l /tmp/log.txt
Notice the "-d 6 -l /tmp/log.txt" which are there to tell linphonec to output all debug messages
into /tmp/log.txt. Looking into this file might be useful should any trouble arrive.
To stop it, do:
linphonecsh exit

Automatic start at boot

In order to have linphonec automatically started when the raspberry boots: you can add this line
to /etc/rc.local :
export PATH=/home/pi/linphone-desktop/OUTPUT/no-ui/bin:$PATH
sudo -u pi linphonecsh init -a -C -c /home/pi/.linphonerc -d 6 -l /tmp/log.txt
The lines above assume that your linphone-desktop source tree is in /home/pi/linphone-desktop.
Please adapt if it is not the case.
Just a final reboot and now you can place calls from your favourite linphone app (mobile or
desktop) to your raspberry, by calling its sip address !

Common hardware problems

If you are using the RaspberryPi Camera, you'll notice it won't show up as a /dev/video entry, thus it
won't be available in linphone for use. To fix that, use the following:
 first enable the camera thanks to the raspi-config utility included in your raspberry.
 tell the raspberry to load the driver specific to the raspberry camera and do it automatically
and next reboot:
sudo bash
modprobe bcm2835-v4l2
echo "bcm2835-v4l2" >> /etc/modules
exit
Sadly, the raspberry loosing the network connectivity is a frequent occurrence. Unfortunately, all
that NetworkManager stuff included with Raspbian was designed for Linux workstation or servers,
and is not robust to temporary network connectivity losses. They happen quite frequently because
of various reasons:
 The internet box looses DSL connection and reboots
 The wifi signal is lost temporarily due to interferences
 The wifi driver has bugs and looses connection after some hours
 The house general power shuts down and comes back due to a thunderstorm, but the
raspberry starts faster than the DSL box and will have no internet at boot time.
I recommend to plug the DSL box onto a programable power timer so that it is restarted every day :
indeed it is not so rare that a DSL box hangs forever and needs a manual reboot.
In order to force the raspberry to check the network periodically and force a re-connection, I
suggest these two scripts, that can be invoked periodically from cron daemon:
 The first one called "restart_wlan0_if_necessary.sh". It just tries a ping to linphone.org, and
in absence of response, trigers a shutdown/restart of the wlan0 network interface.
#!/bin/sh
date
if test -z "`ping -w 5 linphone.org |grep time`" ; then
echo "broken connection, restarting wlan0 now"
/sbin/ifdown wlan0
sleep 1
/sbin/ifup wlan0
echo "wlan0 restarted."
else
echo "Everything ok with network."
fi
 The second one, called "reboot_if_necessary.sh". Its goal is to reboot the raspberry if
network is still not working, which is the case when the wifi driver or hardware has entered
an irrecoverabilly corrupted state.
Sadly, the wifi devices and drivers are generally so bad in terms of robustness, that this kind of trick
is necessary.
#!/bin/sh
date
if test -z "`ping -w 5 linphone.org |grep time`" ; then
echo "broken connection, rebooting now"
/sbin/reboot
else
echo "Everything ok with network."
fi
And here's the crontab file:
5 12 * * * /home/pi/reboot_if_necessary >> /home/pi/reboots.log 2>&1
0* *** /home/pi/restart_wlan0_if_necessary.sh >> /home/pi/restarts.log 2>&1
Use sudo crontab -e to write these lines aboves.
This will schedule restart_wlan0_if_necessary.sh every hour, and reboot_if_necessary every day at
12:05.