E d ic ió n 7 - N O V 2 0 1 2

¡Apóyanos aún más

comprando una
versión impresa de
esta Revista!
U n a R e v i s t a p a r a R a s p b e r r y Pi

¡ A r d u in o y
R asP i se
co n ect an !
EEnneessttaaeeddiicciióónn....
•• IInntteerrrruuppcciioonneess
•• PPii SSoollaarr
•• MMooddoo TTuurrbboo ¡¡CCóómmoo
•• EEvvoolluucciióónn ddeell PPii ggaannaarrssee uunnaa
•• CC++++ ccaarrccaassaa
PPIINNKK ppaarraa
M
Mááss.... RRaassPPii!!
•• EEnnttrreevviissttaa ccoonn llooss
ddeessaarrrroolllaaddoorreess ddee RRaassppbbiiaann
•• HHaaggaa ssuu pprrooppiioo jjuueeggoo ddee llaa
eessccaalleerraa uussaannddoo PPCCBBss
•• LLoo bbáássiiccoo ddeell GGNNUU m maakkee

hhttttpp::///wwwwww..tthheem
maaggppii..ccoom
m

Raspberry Pi es una marca de Raspberry Pi Foundation.

Esta revista fue creada usando un computador Raspberry Pi.
Bienvenidos a la edición 7,

La Raspberry Pi y Arduino son la pareja perfecta para correr aplicaciones en

tiempo real donde se necesita un poquito más de potencia de CPU para control.
Acoplando dos dispositivos abre la posibilidad al uso de toda la gama de shields
del mundo arduino. Mirando al horizonte vemos algunos proyectos bien
interesantes en el futuro.

Traemos una entrevista con el desarrollador líder de Raspbian (el build de Debian
para Raspberry Pi), competiciones y una selección variada de artículos en
programación.

Si Ud. prefiere recibir una copia impresa de MagPi, visite

http://www.modmypi.com y ¡haga su pedido ahora mismo!

Ash Stone, Editor en jefe de MagPi

Ash Stone Matt '0the0judge0'

Editor en jefe / Administrador / Encabezados Administrador / Website
Jason 'Jaseman' Davies Matthew Timmons-Brown
Escritor / Website / Diseño de página Escritor
Meltwater Gordon Henderson
Escritor / Fotógrafo / Diseño de página Escritor
Chris 'tzj' Stagg Colin Deady
Escritor / Fotógrafo / Diseño de página Escritor / Diseño de página
Ian McAlpine Stewart C. Russell
Diseño de página / Gráficos / Escritor Escritor
Joshua Marinacci W.H.Bell
Diseño de página / Gráficos Escritor
Lix Colin Norris
Diseño de página / Gráficos Editor / Gráficos (Encabezado C Cave)
PaisleyBoy Antiloquax
Diseño de página / Gráficos Escritor
Sam Marshall Richard Ryniker
Diseño de página / Gráficos Escritor
Aaron Shaw Alex Kerr
Diseño de página / Gráficos Escritor
Nick
Diseño de página / Gráficos

2
 Contenido
04 PI Y ARDUINO EN ACCION
Programar el arduino usando una Raspberry Pi, por Stewart C. Russell
07 COMPETENCIA DEL MES
Gánese excelentes adiciones a su montaje cortesía de PC Supplies UK
08 PI SOLAR
Al viajar, el sol puede mantener la Pi funcionando, por Meltwater
1 0 LA PLACA “LADDER” DE GORDON
Vaya preparando el soldador, por Gordon Henderson
1 2 GPIO E INTERRUPCIONES
Un repaso por el manejo del GPIO desde la línea de comandos, por Richard Ryniker
1 6 RASPBIAN, LA HISTORIA HASTA AHORA
Una entrevista con Mike Thompson, desarrollador líder de Raspbian, por Colin
1 8 TURBO AJUSTES PARA MAXIMO DESEMPEÑO
Un repaso de cómo afinar la Pi, por Matthew Timmons-Brown
21 EVENTOS DEL MES
Talleres y otros eventos de la comunidad Raspberry
22 PI-EVOLUCION
Una mirada al desarrollo en Raspberry Pi, por Jaseman
24 LAS BASES DE GNU MAKE
Acelerando el desarrollo de código con GNU Make, por W. H. Bell
26 BIENVENIDOS AL CACHE C++
Enfréntese a C++. por Alex Kerr
28 EL SCRATCH PATCH
Aprenda sobre programación defensiva, por Antiloquax.
30 EL TALLER DE PYTHON
Usando argumentos de línea de comandos, por Colin Deady
32 PREGUNTAS Y COMENTARIOS

3
 Raspberry Pi y Arduino
Aunque hay varias placas E/S en desarrollo para la
Raspberry Pi, Arduino está bien establecido. Este artículo
muestra cómo comunicarse con un arduino a través de
Python y el protocolo Firmata.
DIFICULTAD: INTERMEDIA
Este ejemplo combina una salida (Cambiar el
brillo de un LED por medio de un control
deslizante) y una entrada (leer la temperatura
de un sensor, LM35 en nuestro caso).
Materiales requeridos:
Raspberry Pi
Arduino
Conexión a internet
Protoboard (O Placa de pruebas)
Sensor de temperatura LM35
(http://www.ti.com/product/lm35)
1 LED rojo de 5mm
1 resistencia de 1 20 ohm Ω
4 cables con terminal macho (here coloured
red, yellow, blue and black)
1 cable puente para protoboard (1 7.8 mm
or 0.7", here coloured black)
Firmata (http://firmata.org) es un protocolo
serial simple que permite leer y escribir los
puertos de entrada y salida de Arduino desde
una computadora. Es usualmente usado con
el lenguaje de programación gráfica
“Processing” (http://processing.org) pero
tambien hay soporte para otros lenguajes.
Instalando el IDE de Arduino y Firmata
El IDE de Arduino ya está incluido en los
repositorios de Raspbian, de manera que
podrás instalar todo con:
$ sudo apt-get install arduino
Si es la primera vez que lo ejecutas es posible
que el IDE te haga crear una carpeta para
guardar los programas que hagas (llamados
“sketches”).
Como siguiente paso tendrás que elegir el tipo
de placa Arduino que estés usando desde el
menú Herramientas/Tarjeta (En este caso usé
Uno, pero también probé en una vieja placa
Duemilanove).
4
Además tendrás que elegir qué puerto serie
usar en el menú Herramientas/Puerto serial.
Arduino Uno debe estar en /dev/ttyACM0,
placas más viejas suelen usar /dev/ttyUSB0.
Para instalar el sketch del Firmata en tu
Arduino, selecciona File / Examples / Firmata /
StandardFirmata and click en el botón Upload.
El IDE se bloquea momentáneamente
mientras compila y carga el sketch. Si las
luces del Arduino titilan y un mensaje de
“Carga terminada” aparece en el IDE, éxito!
Si aparece cualquier tipo de mensaje de error
en rojo, es probable que sea algo con la
conexión del Arduino.
Recomiendo mucho que conectes tu Arduino
a través de un hub USB con alimentación
externa o entregandole energía directamente
por medio de un transformador ya que la
Raspberry Pi es un poco limitada en lo que
concierne a dar energía por USB.
Si te trabas con algo probá el sitio
http://www.ladyada.net/learn/arduino/
Instalando pyFirmata
pyFirmata es la magia que permite que tu
Arduino con Firmata cargado pueda
comunicarse con Python. Toma algunos
comandos para instalarlo:
$ sudo apt-get install python-serial me
rcurial
$ hg clone https://bitbucket.org/tino/p
yfirmata
$ cd pyfirmata
$ sudo python setup.py install
Si esto funciona podrás eliminar la carpeta
pyFirmata.
$ cd .. ; sudo rm -r pyfirmata
Armando el circuito controlar el brillo del LED con el control
deslizante de la pantalla.
Pon las partes como muestra el diagrama Te darás cuenta que el LED no parece
usando la siguiente tabla como guía: aumentar mucho de brillo más allá del 33%;
no hay una línea directa entre el brillo y el
ARDUINO LM35 voltaje de la entrada PWM.
Si tocas el LM35 vas a ver la lectura de la
+5V +Vs temperatura cambiar. Los sensores LM35 son
un poquito ruidosos, así que vas a notar que
A0 Vout los valores saltar.
Una vez que estés listo, clickea en el botón
GND GND cerrar de la ventana y todo debería salir
limpiamente.
NOTA: Si accidentalmente conectas el LM al El código Python hace tres tareas principales:
revés, pasará de ser un sensor de
temperatura a un remarcable generador de 1 . Prepara la comunicación serial y configura
temperatura -- La quemadura en forma de D los pines de E/S del Arduino.
en mi dedo índice izquierdo me recuerda esto
todos los días… Dos detalles importantes que tenemos que
hacer aquí es preparar un hilo iterador para
detener el desborde del buffer serial de la
ARDUINO LED Raspberry Pi mientras recibe datos del
Arduino, y además esperar a que el Arduino
empiece a enviar datos reales antes de ir al
D3 Ánodo (Pin largo) programa principal.
Cátodo (Pin corto) 2. Definir tres funciones que serán llamadas
por la GUI:
A0 (Conectadoatravésde get_temp() — Esto lee el valor del pin A0 del
laresistenciade120 ohm) Arduino, lo convierte a ° C, y actualiza la
etiqueta de la parte baja de la pantalla.
Ejecutando el código Si estás familiarizado con Arduino, pyFirmata
Copia el programa de la siguiente página y devuelve valores analógicos entre 0,0 y 1 ,0 en
guardalo como arduino_firmata_ty.py. Con lugar de un número entero entre 0 y 1 023.
tu arduino conectado y el circuito cableado, Esta rutina termina pidiéndole al proceso Tk
ejecuta el programa de la siguiente manera: principal que se re programe a si mismo
medio segundo, y de esa forma seguimos
$ python arduino_firmata_tk.py actualizando la temperatura separadamente
del bucle principal.
Le tomará unos pocos segundos a la ventana
en aparecer, y una vez que lo haga, podrás Continúa en la siguiente página...
5
set_brightness() — convierte los valores 0-
1 00 que devuelve el deslizador a un valor
entre 0.0 y 1 .0 de coma flotante y lo envía (lo
escribe) en el pin digital 3 de Arduino.
cleanup() — todo lo que esta rutina hace es
apagar el LED y tratar de cerrar el programa
perfectamente. Por cierto, no siempre
consigue hacerlo; a veces también tendrás
que presionar Ctrl-C en la ventana de la
terminal.
3. Preparar la GUI de Tkinter. Tk (y su versión
para Python, Tkinter) es un sistema GUI
bastante viejo, pero es también bastante
simple de usar.
Depende de cada control gráfico (widget)
para ejecutar una callback (Llamada de
retorno) o asignar el valor de una variable
cuando es clickeado o modificado.
Aquí estoy creando un deslizador de 400px de
ancho que llama a la rutina set_brightness()
con el valor actual del control deslizable cada
vez que éste cambia.
Movido Completamente a la derecha, el
deslizador llamaría a set_brightness(1 00),
encendiendo el LED con el máximo brillo.
Como la ventana es muy simple (Solo un
control deslizante y una etiqueta) uso el
simple método pack() de Tk para ordenar los
elementos en la ventana.
import pyfirmata
from Tkinter import *
# Create a new board object,
# specifying serial port;
# could be /dev/ttyUSB0 for older
# Arduinos
board = pyfirmata.Arduino('/dev/ttyACM0')
# start an iterator thread so
# serial buffer doesn't overflow
iter8 = pyfirmata.util.Iterator(board)
iter8.start()
# set up pins
# A0 Input (LM35)
pin0 = board.get_pin('a:0:i')
# D3 PWM Output (LED)
pin3 = board.get_pin('d:3:p')
# IMPORTANT! discard first reads
# until A0 gets something valid
while pin0.read() is None:
pass
def get_temp():
# LM35 reading in deg C to label
label_text = "Temp: %6.1f C" % (
pin0.read() * 5 * 100)
label.config(text = label_text)
# reschedule after half second
root.after(500, get_temp)
6
Este (el método pack), primero dibuja los
elementos, entonces los acomoda juntos,
como un Tetris, en el marco de la ventana.
Una vez hecho esto, programa la primer
lectura de temperatura (que a su vez
programa la siguiente y así...), finalmente llega
al mainloop() de Tk, ejecutando el resto del
programa, respondiendo a tu control.
Indicaciones adicionales
Este es un ejemplo muy simple de cómo
controlar Arduino desde Python.
Mientras que Firmata puede controlar salidas
más complejas tales como un servo, ya que
se hace cargo de toda la lógica de
procesamiento de Arduino.
Cualquier sensor que requiera una
configuración compleja o control en tiempo
real no va funcionar tan bien.
Igualmente, ahora tendrás todo el poder de la
Raspberry Pi conectada a la simple robustez
de Arduino ¡Ni siquiera el cielo es el límite!
Artículo de Stewart C. Russell
Stewart C. Russel vive en Toronto, donde diseña y crea
granjas eólicas y fuentes de energía solar. Cuando no está
hurgando en el mundo los lugares soleados y con viento, está
en su casa con radio amateur (Matrícula VA3PID), tocando el
banjo, jugando con computadoras, o evadiendo la jardinería.
Su sitio web es http://scruss.com/blog
def set_brightness(x):
# set LED
# Scale widget returns 0 .. 100
# pyfirmata expects 0 .. 1.0
pin3.write(float(x) / 100.0)
def cleanup():
# clean up on exit
# and turn LED back off
pin3.write(0)
board.exit()
# set up GUI
root = Tk()
# ensure cleanup() is called on exit
root.wm_protocol("WM_DELETE_WINDOW",cleanup)
# draw a big slider for LED brightness
scale = Scale(root,
command = set_brightness,
orient = HORIZONTAL,
length = 400,
label = 'Brightness')
scale.pack(anchor = CENTER)
# place label up against scale widget
label = Label(root)
label.pack(anchor = 'nw')
# start temperature read loop
root.after(500, get_temp)
# run Tk event loop
root.mainloop()
 Un Pequeño
Rayo de Sol…
Mientras navegaba buscando dispositivos interesantes para
Raspberry Pi, Me encontré con el siguiente item de
CottonPickersPlace.
Unidad de operación:
Este dispositivo solar funciona esencialmente
como un cargador solar para 4 pilas AA
colocadas internamente, las que a su vez son
capaces de alimentar al propio Raspberry Pi.
El artefacto también sirve como ingenioso
soporte para el Raspberry Pi y,
adicionalmente, también puede ser utilizado
para recargar la mayoría de dispositivos
alimentados por USB.
1 . Los rayos de sol sobre el panel solar.
2. La corriente generada se utiliza para cargar
el pack de pilas (solamente inserte 4 pilas
estándar NiCad/NiMh de tamaño AA de la
capacidad que prefiera).
3. El pack de pilas almacena la energía y la
provee sin problemas incluso cuando esté
poco o nada soleado.
4. ¡La Raspberry Pi es alimentada!
Especificaciones
Panel Solar 1 2 celdas de 330 mA por 2 Watts
policristalino de 1 1 0x1 35mm
Caja Impreso mediante impresora 3D BRB-
3000 utilizando de material PLA (Polylactic
Acid) biodegradable. Típicamente toma 2
hs 1 5 min para imprimir. La Raspberry Pi
cabe cómodamente en su interior.
60x90x45mm
8
A. El conector de alimentación micro USB se
conecta directamente dentro del
Raspberry Pi (perfectamente acomodado
cabeza abajo dentro de la base de la
unidad).
B. El conector USB de tamaño estándar
puede utilizarse para alimentar en forma
directa a la Raspberry Pi, y si las pilas
están descargadas agrega una fuente
externa (la carga a través del sol es
necesaria para cargar completamentes las
celdas). Este plug también puede ser
utilizado en serie con otra unidad solar
para proveer energía solar adicional y
alargar la vida de las pilas (enchufando
dentro del lado del conector USB ( C )).
C. Un conector USB adicional en el costado
de la unidad provee un punto de carga
auxiliar para teléfonos móviles y otros
dispositivos USB. Si es necesario, los
iDevices de Apple como iPods / iPhones /
iPads están soportados con una versión
mejorada.
Salidas típicas
A pleno sol 300 mA+ aprox.
Puesta de sol 200-250mA
Nublado 30mA
Tiempo estimado de carga
A Pleno Ocaso Nublado
Celdasde3000 mAh 1 0h 1 3h20m 1 00h
Celdasde2100 mAh 7h 9h20m 70h
La unidad puede no sobrecargar la celda, y no hay
fugas de carga cuando no se está cargando.
TiempodefuncionamientoestimadodelRaspberryPi
A Pleno Ocaso Nublado Noche
Model B
Celdasde3000 mAh 23h 1 4h30m 7h30m 7h
Celdasde2100 mAh 1 6h 1 0h1 5m 5h1 5m 4h50m
Model A
Celdasde3000 mAh Charge 40h 11h 1 0h
Celdasde2100 mAh Charge 28h 7h45m 7h
Modelo B - Consumo de potencia característico estimativo:
430 mA dependiendo de lo que está conectado (rango
desde 322 mA en reposo a picos de 480 mA + )
Modelo A - Eben declaró que está alrededor de los 200 mA,
por lo tanto aceptemos 300 mA como una estimación
conservadora.
Consideraciones de uso:
Mis propios testeos con algunas viejas celdas
de 2500 mAh proporcionaron alrededor de 4
horas de uso nocturno, es razonable
considerando que las pilas tienen varios años
de antigüedad.
Usando la cantidad mínima de periféricos y
utilizando el más eficiente Raspberry Pi
modelo A (cuando se libere) debería
extenderse en gran medida el tiempo de uso.
La eficiencia del Raspberry Pi también puede
ser mejorada reemplazando el regulador lineal
de 3,3 V incorporado con un modelo más
eficiente en modo de conmutación, una
medida extrema, pero se reportó que puede
ahorrar alrededor de un 25% de energía (vea
http://goo.gl/dqUZL para detalles).
Aunque el Raspberry Pi puede utilizarse en
muchas situaciones de forma remota, a
menudo va a querer utilizarlo con una
pantalla. Actualmente, la mayoría de las
pantallas requerirán algo o bastante más de
energía que el propio Raspberry Pi. Esto
puede llegar a mejorarse cuando la fundación
pueda suministrar pantallas LCD operadas
directamente por el Raspberry Pi, en última
instancia, requiriendo menos energía que un
monitor LCD típico o una TV. Para este fin una
pantalla super eficiente basado en tinta
electrónica podría ser una excelente opción,
crucemos los dedos para que se haga
realidad.
Para una operación remota durante las 24
horas (algo que muchos usuarios de
Raspberry Pi desean), es probable que sean
necesarias 2 o más unidades solares y un sol
a pleno. Adicionalmente, mediante el diseño
de algunos métodos para apagar
remotamente la fuente de alimentación de la
Raspberry Pi y volverla a encender cuando
sea necesario, significaría la viabillidad una
configuración remota desatendida. Tal
sistema podría incluso controlar los niveles de
batería disponibles y en consecuencia
encender la Raspberry Pi o establecer un
periodo de tiempo determinado para las
operaciones. ¡Nos encantaría oír sobre algún
diseño adecuado!
Conclusiones:
La unidad compacta presenta una serie de
características flexibles y presenta una buena
solución para ejecutar el Raspberry Pi con
baterías.
El agregado del panel solar extiende bastante
el tiempo de funcionamiento del sistema
(particularmente si usted vive en un clima muy
soleado) o permite cargar durante el día y a su
vez el uso nocturno durante horas. Cuando
está enchufado a la red eléctrica ofrece
excelente protección contra los cortes de luz,
en efecto funciona como una UPS (sistema de
alimentación ininterrumpida). La unidad
también provee un medio para trasladar
rápidamente el aparato a varios lugares sin
tener que apagar la alimentación (ideal para
moverse rápidamente a una pantalla grande
para reproducir algunas películas, sin la
molestia habitual de encontrar un enchufe
disponible, arrancar el sistema, etc.).
CottonPickersPlace está trabajando en varios
modelos de paneles grandes que soportan
baterías también más grandes, que deben ser
capaz de gestionar las operaciones en 24/7
y/o al mismo tiempo alimentar pantallas de
terceros, etc.
En general, la unidad ofrece gran flexibilidad a
un excelente costo (alrededor de 25 libras
incluyendo envío en UK, 49 u$s incluyendo
envío para el resto del mundo ). Es muy claro
que se ha puesto mucho tiempo y esfuerzo en
cada unidad hecha a mano. CottonPicker ha
puesto claramente la atención en el diseño
para que el costo general permanezca tan
bajo como sea posible sin comprometer en
calidad o características, en mi opinión
alcanzando un gran equilibrio.
¡Esta puede ser la pieza faltante que usted ha
estado buscando para completar su proyecto
o también una práctica caja que le permita
cortar el cable de alimentación cuando usted
quiera!
Artículo original de Meltwater
Disponible en:
www.cottonpickersplace.com
Enlace directo: goo.gl/w9Rs3
9
 La placa Raspberry Ladder
La placa Raspberry
Ladder es un kit de
piezas destinadas a ser
utilizadas como una
introducción a la
soldadura y a la
programación de GPIO
del Raspberry Pi.
La placa Ladder se basa en mi
juego Ladder original que hice a
principios de este año en un
circuito experimental, cuyos
detalles se pueden encontrar aquí:
https://projects.drogon.net/raspber
ry-pi/gpio-examples/ladder-game/
Esta versión ha sido modificada
para hacerla más útil para otros
proyectos y ojalá te anime a
escribir tus propios juegos
pequeños y simulaciones. El
software que voy a ofrecer será
una versión de mi juego Ladder
original, mi simulador de cruce
Tuxx y una nueva versión de
"Simon Dice".
El kit incluye un PCB hecho
profesionalmente, 8 LEDs
estándar (2 de cada uno en azul,
verde, amarillo y rojo), 2 LEDs
más pequeños (verde y rojo), 4
interruptores de pulsador, 1 4
resistencias para los LEDs y
conmutadores, y un breve (a
medida) cable plano y conectores
IDC para conectar la placa a la
Raspberry Pi Ladder.
Necesitará un equipo básico de
soldadura, (soldador, estaño, un
par de cortadores de alambre) y
un tiempo de montar la placa.
Además un poco de spray
limpiador de PCB puede ser útil
una vez que todo está terminado,
pero no es esencial. Si se siente
cómodo con la soldadura
entonces no debería tomar más de
1 0-1 5 minutos para montar
completamente el tablero, pero si
no es así, se puede hacer por
etapas, e incluso se puede probar
cada etapa a medida que avanza.
Usted puede comprar el kit
completo incluyendo PCB de
10
Prototipo Placa Raspberry Ladder y PCB
Tandy por £ 7.00 incluyendo los agujeros que se utilizan para el
gastos de envío. conector de cable-cinta.
http://www.tandyonline.co.uk/elect
ronics/kits/raspberry-ladder- En primer lugar tenemos que
kit.html identificar qué resistencias son
cuáles. En el juego hay 2 tipos,
220Ω y 1 000Ω. Los 220Ω se
La soldadura de la versión PCB:
Soldar no es difícil, pero requiere identifican por el color de sus
práctica. Antes de comenzar, por bandas - Rojo, Rojo, Marrón, y los
favor lea este cómic: que son 1 000Ω Marrón, Negro,
http://mightyohm.com/soldercomic Rojo. Sin embargo, si estás
confundido, entonces fijate que
hay 1 0 de 220Ω y 4 de 1 000Ω -
Una vez concluida la lectura, echa sólo cuéntalas para ver cuál es
un vistazo a la placa y los cuál.
componentes - no quite los
componentes de sus paquetes en Comienza con las resistencias de
esta etapa - el kit de Tandy será 4 x 1 000Ω. Dobla las patas al final
embalado en las bolsas en el de la resistencia e insértalas en el
orden en que usted los necesita, PCB en las 4 ubicaciones. Las
pero vea si puede identificar todo
resistencias pueden ubicarse de
lo primero. Estudia la foto de la cualquier forma, pero se ven mejor
placa totalmente montada para ver si todas se alinean de la misma
lo que puedes esperar. manera. Empuja las patas de las
resistencias a través de sus
Compruebe la PCB - Busca signos agujeros y dóblalas hacia el
evidentes de daño y determina si exterior, como se muestra en la
los componentes están montados. página 4 de la historieta anterior.
Los símbolos blancos impresos
serán de ayuda. Las resistencias Me gusta poner todas las cuatro a
tienen pequeños rectángulos, los la vez y luego usar algo como blu-
interruptores rectángulos más tak para mantenerlos en su lugar
grandes (casi cuadrados), y los cuando me pongo a soldar la
LEDs tienen círculos con un lado placa, pero puede que desees
plano. Hay una corta hilera de 5 hacerlo una a la vez, para
agujeros que no se utilizan en este empezar.
proyecto y 2 filas más largas de
Montaje:
Se necesitan 2 manos, así que
asegúrate de que la placa esté
asegurada. También es una buena
idea estar en un lugar bien iluminado
¡para que puedas ver lo que estás
haciendo! Mira el vídeo para más
ideas, sin embargo, en general, toca
con el soldador al mismo tiempo la
pata del componente y la pista,
espera 1 o 2 segundos, toca la
soldadura con la pista o con el final
del estaño - que debería fluir
inmediatamente y llenar todos los
huecos. Retire el material de
soldadura, y luego (¡esta parte es
muy importante!) Mantenga el estaño
allí por un segundo o dos.
La mayoría de los componentes se
dañan por exceso de calor, pero no
tenga miedo para mantener el calor
allí durante un máximo de 1 0
segundos si es necesario. Con la
práctica, usted debería ser capaz de
hacer una unión de soldadura en
unos 5 segundos. Estaño a la placa y
al cable del componente, pausa,
suelda hasta que fluya, pausa, quitar
estaño. Si sientes que no quedó una
buena unión, espera un momento
para que se enfríe y vuelve a
intentarlo.
Asegúrate de que el estaño esté
limpio cada vez que lo recoja - utiliza
una esponja húmeda o el nuevo
sistema "limpiado en seco" que se
parece a una esponja metálica.
Una vez que hayas soldado los
primeros componentes (¡o 4
primeros!) entonces es el momento
de acortar los cables. Una vez más,
este es un trabajo de 2 manos y
tienes que sujetar el extremo de la
punta cuando se corta - si no lo
haces, entonces se irá volando y
cuando te golpee dolerá. (Además tu
pareja, madre, etc, ¡no será feliz
limpiando el desastre de pequeños
picos pequeños de metal!) Sostén el
extremo y corta justo al lado de la
unión de soldadura y ponla en el
recipiente de deshechos.
Una vez que tengas las 4 primeras
resistencias soldadas, puedes
progresar a las resistencias de 220Ω.
Comienza con las 2 en la parte
superior de la placa, a continuación,
las otras 8 en el costado.
Lo siguiente es los interruptores.
Estos deben mantenerse en la placa Pruebas:
durante la soldadura, pero asegúrate El software de prueba utiliza el
de ponerlos en la posición correcta - comando wiringPi GPIO, por lo
son ligeramente rectangulares, así que necesita wiringPi instalado
que si no parecen encajar, gira un primero.
cuarto de vuelta y vuelve a intentarlo.
Ahora los LEDs. Esperemos que Para wiringPi (si no lo tiene):
ahora hayas conseguido $ cd
acostumbrarte a la soldadura. Dejé $ git clone
los LEDs hasta ahora por 2 razones - git://git.drogon.net/wiringPi
en primer lugar por lo general es $ cd WiringPi
mejor para soldar los componentes $ ./bulid
bajos primero y luego los más altos, y
también para darle un montón de
prácticas de soldadura con las Para el software Raspberry Ladder:
resistencias y los interruptores que $ cd
son más resistentes al $ git clone
sobrecalentamiento que los LEDs. git://git.drogon.net/ladder
Aún debe estar bien por un máximo $ cd ladder
de 1 0 segundos con los LEDs, pero
espero que ahora puedas ser un poco
más rápido y seguro. Y para ejecutar el programa de prueba:
$ ./ladderTest.sh
Los LED son sensibles a la forma en Esto debería llevarte a través de
la que entran, así que mira con unos sencillos pasos para
cuidado. Tienen un lado aplanado y comprobar que la tarjeta funciona
esto corresponde al lado aplanado en correctamente.
la imagen de la PCB. El lado plano
siempre va hacia la pista negativa del
circuito, y el otro lado (que tiene una Una versión ligeramente modificada
pata más larga), siempre va hacia la del programa Tux Crossing también
pista positiva del circuito. está ahí - ejecutarlo con:
$ ./tuxx.sh
Tómate tu tiempo al soldarlos - trata
de asegúrate de que todos encajen Y cuando se inicializa, presiona el
completamente en el PCB, y que botón de abajo para iniciar la
estén alineados en una línea secuencia. ¡Más detalles del
ordenada. software y los datos el mes que
viene!
Por último, el conector GPIO. Ajústalo
en el tablero, asegúralo, suelda un pin
y luego comprueba antes de soldar el La documentación completa se
resto. Es posible que desees bajar suministra en el archivo README
una línea, a continuación, gira la sobre cómo se conectan los
placa y baja por la otra línea. LEDs, y el programa ladderTest
es un script bash que usted puede
Y hemos terminado. Esperemos que copiar y editar según sea
tu placa terminada se vea como la de necesario, también puede ver
la página siguiente. algunos de los programas de
ejemplo GPIO suministrados con
Ahora es el momento de conectarla a el paquete wiringPi, pero la
un Raspberry Pi y ejecutar el software
verdadera diversión comienza el
de prueba. Nota: la primera vez que próximo mes cuando escribiremos
enciendas el Raspberry Pi, o lo
reinicies con el tablero Ladder algunos programas más para
conectado, los dos LEDs más esto.
pequeños pueden estar débilmente
resplandecientes. Esto es de
esperarse, ya que está siendo
alimentado con corriente de las
resistencias I2C pull-up integradas
del Pi que forman parte del bus I2C.
Artículo por Gordon
11
 Interrupciones y otras actividades
con los pines del GPIO
Cómo compartir los recursos del GPIO entre múltiples
aplicaciones, y el uso de las interrupciones para reemplazar
bucles de control de estado poco económicos.
Después de hacer algunos experimentos
iniciales donde la Raspberry Pi opera con
LEDs y lee switchs, cuando se apaga la
euforia del “Funciona!”, usuarios inteligentes
pueden comprender que tendrán problemas
cuando se encarguen de extender esos
simples programas a entornos más
complejos.
Aquí discutiré dos de esas cuestiones: cómo
compartir recursos de GPIO entre múltiples
aplicaciones, y el uso de las interrupciones
para reemplazar bucles de control de estado
poco eficientes.
Se ha producido con horrible frecuencia
instrucciones del tipo "Ejecute este programa
como root." publicadas para el usuario de
Raspberry Pi. Esto, a un usuario con
experiencia le suena más bien como “Aquí
niños: estas son hojas de afeitar. Agárrenlas,
y vean lo que pueden cortar con ellas.”
Los privilegios de root deben ser vistos como
una última alternativa. Su uso adecuado es
para la instalación del sistema y la
configuración - el establecimiento de un
entorno protegido donde la falla en un
programa no pueda afectar a otras
aplicaciones, y no cause fallos al sistema
operativo. En el peor caso, un programa que
se equivoca debe comprometer solamente
los recursos asociados a ese programa.
Linux posee una gran cantidad de
administradores de dispositivos (drivers),
programas que generalmente forman parte
del kernel y hacen de interfaz entre los
recursos de hardware y las aplicaciones.
Ejemplos de esto son los archivos de
sistema, que ofrecen funciones simples de
utilizar como open, read y write, mientras
ellos administran el acceso a hardware y
mantienen la estructura de datos necesaria
para asignar y liberar espacio en disco,
compartir el acceso de manera adecuada
entre múltiples programas, manejar la
recuperación después de eventos como fallas
de energía.
12
Los privilegios de root hacen más fácil
interferir con las actividades del sistema. Si
uno tiene suerte, el resultado es un kernel
panic inmediato y el sistema se paraliza. En
las circunstancias menos afortunadas podría
llegar a ser instalado un software malicioso
en el sistema: este software puede entonces
comunicarse mediante una conexión a
internet con criminales que buscan
información personal o podrían explotar su
Raspberry Pi para actividades dañinas.
Linux tiene una función general para
administrar los recursos de GPIO. Esta, crea
una interfaz conveniente para programas del
usuario, protege los recursos de GPIO
utilizados por administradores de dispositivos
como I2C y SPI y entrega acceso específico
a pines, por lo que una aplicación no
necesita preocuparse de lo que otros
programas hacen con los demás pines GPIO.
Esta interfaz de pines individuales es
importante porque sin ella, cada aplicación
GPIO tendría que preocuparse por los
aspectos de la pugna con otras aplicaciones
que comparten un banco de pines GPIO
(bloqueos, gestión de interrupciones, u otras
complejidades que fueran necesarias).
La función de Linux utiliza archivos del
directorio /sys/class/gpio/. Al igual que
muchos otros archivos de configuración o de
control, estos archivos tienen al root como
propietario. Voy a pasar esto por alto, por
ahora, para hacer más fácil la descripción de
la interfaz, pero prometo que más tarde
volveré y presentaré una herramienta para
encapsular la operación de privilegios de una
manera responsable.
Configurando los pines
El comando echo es comúnmente utilizado
en los procedimientos shell para enviar
mensajes a la salida estándar, o mediante la
salida redireccionada para escribir en un
archivo. Un ejemplo simple:
echo Hello there.
Imprime la salida “Hola.” Con redirección de
la salida:
echo Hello there. >archivo_01
Crea el archivo “archivo_01 ” que contiene el
mismo mensaje.
El comando echo puede ser utilizado para
ejemplificar el uso de GPIO. Usaremos el pin
23 porque es conveniente y fácilmente
accesible en el terminal 1 6 del conector de
26 contactos del Raspberry Pi. Se encuentra
etiquetado como GPIO_GEN4 en el
diagrama esquemático del Raspberry-Pi
(http://www.raspberrypi.org/wp-content/up-
loads/201 2/04/Raspberry-Pi-Schematics-
R1 .0.pdf).
Para crear una interfaz de usuario para el pin
23, utilice sudo o, como root, ejecute:
echo 23 >/sys/class/gpio/export
Esto provoca que el kernel genere un
directorio /sys/class/gpio/gpio23, el cual
contiene cuatro archivos importantes para
esta discusión: active_low, direction, edge y
value. Los valores iniciales en estos archivos
(si no hubiera conexión externa a este pin)
son:
active_low 0 pin es puesto a nivel bajo, etc.
direction in
edge none
value 0
Para establecerlo como un pin de salida:
echo out
>/sys/class/gpio/gpio23/direction
Si el valor de salida debiera ser inicializado
primero, antes que el driver de salida sea
habilitado, puede utilizarse para establecer la
dirección del pin con un valor inicial, uno de
los siguientes:
echo low >/sys/class/gpio/gpio23/
direction
echo high
>/sys/class/gpio/gpio23/direction
Please note GPIO reference changes for
pins 3,5,7 & 13 on Revision 2.0
Para establecer la salida del pin en on u off:
echo 1 >/sys/class/gpio/gpio23/value
echo 0 >/sys/class/gpio/gpio23/value
Para invertir la lógica del pin:
echo 1 >/sys/class/gpio/gpio23/
active_low
Haga esto antes de leer una entrada o
establecer un valor de salida. Cuando
active_low contiene 1 (o cualquier valor
distinto de 0) y value es establecido en 1 , el
Continúa en la siguiente página
13
 ¿Con qué rapidez este mecanismo cambia
los valores del pin de GPIO? Un simple
programa en Python
http://ryniker.ods.org/raspberrypi/MagPi/gpio2
3-max.py puede generar pulsos a 1 9 kHz. Si
fuera escrito en C (ver
http://ryniker.ods.org/raspberrypi/MagPi/23-
maxa.c) la frecuencia se incrementa
aproximadamente a 1 20 kHz. La frecuencia
real varía a causa de que el Raspberry Pi
hace otras cosas que suspenden
temporariamente el bucle: la actualización del
reloj, la actividad de red, otros procesos de
usuario o de sistema.
El programa
Como prometí anteriormente, aquí está el
programa
http://ryniker.ods.org/raspberrypi/MagPi/gpi-
o_control.c que ejecuta operaciones que
requieren privilegios de root para poder
exportar un pin GPIO para el uso por
usuarios comunes. Los comentarios al
principio del programa describen como debe
compilarlo e instalarlo. Cuando sea instalado
(por el root), debido a su característica de
“setuid”, el programa se ejecuta
efectivamente con un id de usuario root, por
lo tanto tiene los privilegios necesarios para
exportar o dejar de exportar por un pin de
GPIO.
Los programas que se ejecutan con
privilegios de root deben ser escritos por
programadores realmente paranoicos. La
mayoría del código en gpio_control.c
simplemente verifica que el argumento sea
razonable, y trata de ser informativo si
sucede algo inesperado.
Para utilizar gpio_control.c para salida por el
pin 23, para que todo el manejo del pin
comentados anteriormente no requieran
privilegios de root, simplemente ejecute:
gpio_control 23 export
14
gpio_control.c puede ser fácilmente
configurado antes de ser compilado, para
permitir el acceso a GPIO a todos los
usuarios o solamente los usuarios de un
grupo. Cada uno de los 54 pines de GPIO
pueden ser configurados individualmente
para permitir o rechazar las salida.
El Raspberry Pi utiliza el pin 1 6 de GPIO
para controlar el led verde de “status ok”. Si
alguien trata de salir por el pin 1 6 del GPIO la
operación falla porque el kernel está
utilizando ese recurso:
ryniker@raspberrypi:~$ gpio_control
16 export
export failed: Device or resource busy
Otros programas del kernel pueden
adueñarse de pines del GPIO haciéndolos
inaccesibles a los usuarios. Esto es bueno.
Poco daño puede provenir de un usuario
cambiando el LED de estado a encendido o
apagado, pero ¿qué pasa con el controlador
del I2C del kernel? Fácilmente podría sufrir
fallos erráticos si los pines que utiliza son
cambiados de un modo que no puede
entender.
El kernel recuerda el estado de los pines de
GPIO. Por ejemplo, suponga que un pin es
exportado, establecido como un pin de salida
por el usuario, luego dejado de exportar. Los
archivos del usuario desaparecen pero el pin
permanece como un pin de salida con el
último valor establecido. Si este pin vuelve a
ser exportado, los archivos del usuario son
re-escritos para mostrar el estado guardado.
El comando echo es conveniente para usar
en shell scripts, ocasionalmente en la línea
de comandos, pero Python es mucho más
fácil para los programadores. La docena de
líneas de código en gpio23-max.py debería
proveer de un ejemplo simple.
Ahora que se han enseñado los elementos
básicos de control de GPIO, esta función se
puede utilizar para reemplazar la operación
de “bucle infinito”, donde un programa lee
repetidamente el valor de una señal de
entrada y realiza alguna operación cuando
esta cambia, por un programa infinitamente
más eficiente que solamente se ejecuta
cuando la señal cambia. Con sólo una
entrada y absolutamente nada más que
hacer hasta que cambie, un loop puede ser
un problema. Sin embargo, este tipo de bucle
consume el 1 00% de los recursos del CPU, y
entonces compite agresivamente con todo
aquello que pueda querer un poco de
Raspberry Pi.
Se puede introducir un retardo en el bucle de
sondeo (poll loop), para esto utilice el
comando “sleep 0.5” para un retraso de
medio segundo antes de comenzar la
siguiente iteración del bucle. Esto permitiría
que otra actividad se ejecute durante el
período de demora. Pero significa que hay un
retraso promedio de un cuarto de segundo
antes que se detecte cualquier cambio en la
entrada. Más corto el retardo, la respuesta es
más rápida, pero hay más desperdicio de
CPU... Fea elección.
A medida que el número de entradas crece y
el número de respuestas a esas entradas se
hace más grande y más variada, a menudo
es necesario administrar las tareas con
diferentes prioridades. Las interrupciones son
el medio para conectar rápidamente una
entrada como "hay un precipicio directamente
delante del vehículo" a la respuesta
"¡Frenar!".
Otro programa Python
http://ryniker.ods.org/raspberrypi/MagPi/inter-
rupt_test23.py quiere ilustrar el manejo de
interrupciones del GPIO. Este programa
configura el pin 23 como
una entrada, establece el archivo edge a
“both” (ambos flancos) en consecuencia las
interrupciones ocurrirán por las transiciones
“falling” y “rising” (flancos descendentes y
ascendentes), luego abre el archivo value de
los pines. El llamado a select.poll() crea un
objeto polling llamado “po”, después
po.register() agrega el archivo value como
una de las fuentes que pueden corresponder
a un llamado posterior a po.poll(). Este
programa utiliza una única fuente de
interrupción, pero pueden ser registrados
otros pines GPIO y muchas otras fuentes por
el objeto poll. Por ejemplo, un pipe ( ‘|’ ) que
se conecta con otro proceso puede ser una
fuente de interrupción o un socket que recibe
datos a través de una red desde un sistema
remoto.
El segundo operando de po.register
especifica cuál de las tres condiciones se
reconocerá como interrupción. El valor
select.POLLPRI indica que solamente
“priority data to read” puede causar la
interrupción. Las otras posibles condiciones
(”data available” y “ready for output”) son
siempre verdaderas para un pin GPIO, por lo
tanto en una operación de poll (sensado)
cuando es activada cualquiera de estas,
terminaría siempre de forma inmediata. Si
otra fuente de interrupción es registrada por
po, podría utilizar esas condiciones.
Algunas veces, la ausencia de una señal
esperada puede ser importante. La llamada a
po.poll(60000) esperará por una interrupción,
pero sólo por 60 segundos (60.000
milisegundos) antes de retornar una lista
vacía de señales de interrupción para indicar
que se agotó el tiempo de espera.
El kernel mantiene el archivo value de un pin
GPIO con dos bytes de contenido: un
carácter 0 o un 1 para representar el valor
actual del pin y un carácter de salto de línea.
La función f.seek(0) reinicializa la posición
actual al comienzo del archivo, para que
pueda leerse de nuevo el valor del primer
carácter.
Expandiendo el GPIO
Sólo algunos pines de GPIO son accesibles
en el Raspberry Pi, pero mucha gente ha
demostrado cómo con integrados baratos
como el MCP2301 7 se puede utilizar la
interfaz I2C para expandir este número. Un
diseño como http://shop.ciseco.co.uk/k002-
slice-of-pi-o/ puede ser utilizado hasta 8
veces para añadir 1 28 pines de E/S digital al
Raspberry Pi. Utilice la interrupción con el
MCP2301 7 con una configuración open-drain
para conectar la señal de interrupción de
múltiples dispositivos a un único pin GPIO.
Una resistencia pull-up a 3,3 V para
mantener la entrada en nivel alto hasta que
un dispositivo conectado lo conduzca a nivel
bajo. Cuando ocurre una interrupción el
manejador de interrupciones tiene que leer
valores de todos los dispositivos generadores
de interrupción para descubrir cual de ellos
tiene la señal de interrupción activa (pueden
ser varios), lanzar el programa de respuesta
asociado, luego limpiar todas los solicitudes
de interrupción (por lo que la entrada GPIO
vuelve al estado alto) para permitir que
ocurra la siguiente interrupción.
Un resumen de las URL
Esquema del Raspberry P:
http://www.raspberrypi.org/wp-content/up-
loads/201 2/04/Raspberry-Pi-Schematics-R1 .0.pdf
Los programas:
http://ryniker.ods.org/raspberrypi/MagPi/gpio23-
max.py
http://ryniker.ods.org/raspberrypi/MagPi/23-maxa.c
Expansor de E/S:
http://shop.ciseco.co.uk/k002-slice-of-pi-o/
Artículo originalde RichardRyniker
15
 Entrevista con Mike Thompson
La distribución Raspbian de Debian provee el sistema operativo encontrado en la
mayoría de las Raspberry PI. En este número de The MagPi entrevistamos a Mike
Thompson, el fundador de Raspbian.
Q: ¿Por qué decidiste empezar Raspbian?
Leí en enero que la Fundación estaba
planeando usar Fedora y me pregunté si yo
podría hacer lo mismo pero con Debian, ya
que es mi distribución de Linux favorita para
procesadores ARM. Durante mucho tiempo he
estado interesado en aprender como crear un
sistema operativo y, además, contribuir con la
comunidad Debian. Raspbian me dio esa
oportunidad.
Me di cuenta que iba a tomar una buena
cantidad de recursos, tiempo y esfuerzo crear
Raspbian. Empecé haciendo preguntas en los
foros para entender qué se debería tener en
cuenta para llevar a cabo una tarea así.
Hurgué por ahí para ver como lograrlo y se fue
desarrollando de ahí.
Raspbian es un esfuerzo conjunto entre Peter
Green (Plugwash), que es un desarrollador de
Debian, y yo.
Q: ¿Por qué elegiste la Raspberry Pi
habiendo disponible otras placas de relativo
bajo costo?
Tengo un interés personal en sistemas Linux
de bajo costo y me anima que la Fundación
Raspberry Pi haya demostrado el deseo y la
necesidad que existe en el mercado por un
sistema como la Raspberry Pi. A la larga sería
interesante llegar a ver ese tipo de placas a
un precio de entre US$5-1 0. Puede que tome
unos años llegar a eso, pero las cosas pueden
volverse mucho más interesantes en el mundo
cuando haya acceso a gran escala de
computadoras baratas y relativamente
sofisticadas como la Raspberry Pi.
Q: ¿Cómo llegaste de tener una versión
funcional de Raspbian a ser el Sistema
Operativo (SO en adelante) oficial de la
Fundación Raspberry Pi?
Peter Green y yo estábamos bastante
encaminados en el proyecto cuando a
mediados de junio tuvimos pistas de que la
Fundación estaba interesada en Raspbian.
Cuando yo empecé, mi expectativa era crear
una alternativa a Fedora que sea usada,
quizás, por el 1 0-20% de los usuarios de
16
Raspberry Pi y nunca esperé que Raspbian se
convirtiera en la distribución Linux “oficial” de
la Raspberry Pi. Después de lanzar las
primeras imágenes de testeo de Raspbian y
una significativa parte del repositorio fue
creado, la gente empezó entusiasmarse
diciendo que ellos esperaban que la
Fundación eligiera una distribución basada en
Debian. Yo sabía que la Fundación estaba
enterada de Raspbian por los foros y que si
ellos pensaban que valía la pena podrían
elegir usarla.
Q: ¿En qué difieren los lanzamientos de
Raspbian y de la Fundación?
Raspbian es una recopilación de los paquetes
que componen la distribución Debian ARM
Wheezy hardfloat pero compilado para
procesadores ARMv6 como el de la
Raspberry Pi. Estamos usando el trabajo que
la Fundación hizo sobre el kernel sin tocarlo
porque las interfaces binarias en el kernel no
tienen componentes de punto de coma
flotante. Eso nos ahorró un montón de
esfuerzo permitiéndonos concentrar en la
recompilación de los paquetes.
Alex Bradbury, el desarrollador líder de la
Fundación, trabajó en la imagen de Raspbian
de la Fundación. Como Raspbian es
esencialmente un clon de Debian él tomó los
mismos scripts que había usado para la
imagen basada en Debian, hizo cambios
menores y los usó para crear su propia
imagen basada en Raspbian. Creo que
estaba agradecido de ver que nosotros
seguimos estrictamente la distribución
Debian, por lo tanto el proceso para crear una
versión de Debian optimizada para la
Raspberry Pi basada en nuestros paquetes de
Raspbian fue bastante simple.
Q: ¿Qué tan conveniente resultó ser la placa
Freescale iMX53 que compraste en marzo
como plataforma de creación?
Todavía estamos usando 8 placas Freescale
iMX53 para compilar los paquetes de
Raspbian. Son sistemas bastante rápidos con
un procesador ARMv7 de 1 Ghz con 1 GB de
RAM. Cuando compilamos, algunos de los
paquetes requieren un montón de memoria
RAM para crear las enormes estructuras
enlazadas, y nosotros usamos archivos de
intercambio (Swap) de 1 ,5-2GB así que
estamos excediendo la memoria disponible.
Una típica PC moderna con 4GB de RAM
puede tomarle cerca de 1 hora compilar un
paquete grande, pero en esos sistemas ARM
puede tomar más de 30 horas. Tener 8
sistemas disponible para compilaciones en
paralelo fue necesario en mayo y junio cuando
estuvimos compilando el total de 1 8000
paquetes fuente que equivale a poco menos
de 38000 paquetes binarios para Raspbian.
Si sólo tuviéramos un sistema, hoy en día
todavía estaríamos compilando paquetes.
Estamos usando versiones modificadas de las
herramientas de Debian para compilación
para distribuir el compilado de paquetes a
través de los 8 sistemas.
Yo llegué a este proyecto con muy poca
experiencia en creación de sistemas
operativos y tuve que aprender todo lo
necesario. Afortunadamente para mi, Peter
Green se unió al proyecto y su experiencia
con Debian y sus herramientas de
compilación fue esencial para hacer Raspbian
posible. Fui desarrollador de software toda mi
carrera pero nunca encaré algo de esta
escala. Ahora entiendo por qué las compañías
de software tienen ingenieros especializados
en compilaciones de proyectos enormes
Q: ¿Qué tan dependiente fuiste del trabajo
hecho por la comunidad Linux?
Extremadamente dependiente. Raspbian no
habría sido posible si el grupo de Debian que
creó armhf (ARM Hard Float) no hubiese
hecho el trabajo preliminar 1 8 meses antes,
aunque ellos implementaron ARMv7 y no
ARMv6. Peter Green y yo pensamos que
Raspbian debe ser lo más parecido a una
versión oficial de Debian como sea posible sin
ser una versión oficial. Mientras
mantengamos ese compromiso con
Raspbian, se mantendrá una base sólida para
la Fundación Raspberry Pi y la comunidad.
Posteriormente, manteniendo Raspbian tan
similar a Debian reducimos el riesgo de que
sólo dos personas trabajen en ello. Peter
Green se aseguró que todo lo que hicimos sea
completamente abierto. Si nosotros
dejáramos de trabajar mañana nuestro
trabajo está ahí afuera, espejado en 30-40
servidores alrededor del mundo. Cualquiera
con el conocimiento en compilar Debian
puede fácilmente tomar eso y seguir
manteniéndolo. Por lo tanto Raspbian es de
poco riesgo para la Fundación.
Q: ¿Hay algun otra mejora de rendimiento
que pueda lograrse en Raspbian?
Yo creo que llegamos al máximo en la parte
de software. Reemplazando el CPU con un
procesador que soporte ARMv7 o agregando
más memoria [Nota del editor: la Pi acaba de
empezar a salir con 51 2MB de RAM!] sería
grandioso ya que algunas personas están
llegando a los límites de la placa, por ejemplo
con la navegación web en un GUI de
escritorio.
Creo que, en general, la eficiencia de software
ha ido por el buen camino, especialmente con
aplicaciones GUI. Yo siempre valoré el uso
ágil y eficiente de memoria para computar.
Desafortunadamente la realidad es que un
montón de RAM y un CPU poderoso es
necesario hoy para la mayoría de las
aplicaciones con GUI. Nosotros todavía
deberíamos alentar a la gente a aprender a
programar eficientemente con recursos
limitados. Si sistemas como la Raspberry Pi
hubieran estado disponibles ocho años atrás
podríamos haber visto un ágil sector de
software de productividad requiriendo menos
recursos en general, en todas las plataformas.
Comparado con Turbo Pascal que salió para
CP/M (Un sistema operativo) a principios de
1 980, y después Turbo C, ambos tenían un
entorno de desarrollo pequeño, rápido y
totalmente integrado. Los entornos nuevos
basados en GUIs consumen una enorme
cantidad de recursos y no siempre funcionan
bien, sí lo hacen en la Raspberry Pi. Es triste
que hoy en día no haya un equivalente real a
Turbo Pascal o Turbo C en la Raspberry Pi ya
que esos sistemas desaparecieron cuando
llegaron las GUIs. Yo creo que hay una gran
oportunidad para volver a usar ese tipo de
herramientas para los, comparativamente,
bajos recursos de la Raspberry Pi.
Q: ¿Qué trabajo queda por hacer en
Raspbian?
Ahora estamos mayormente en modo de
mantenimiento. Cuando Debian saca
actualizaciones de paquetes nosotros los
bajamos, recompilamos para Raspbian, y los
enviamos al repositorio. Personalmente, yo
conseguí mi objetivo con Raspbian de crear
una versión que soporte ARMv6 de la versión
hardfloat de Debian.
Estoy feliz que Raspbian haya habilitado
tantas cosas en la comunidad Raspberry Pi.
Además es grandioso que haya podido
devolver algo a la extensa comunidad Linux y
espero que esto dé lugar a miles de nuevos
usuarios de Debian en el futuro.
Mike Thompson es un Ingeniero en Computación viviendo en
San Francisco Bay Area. Tiene un diverso conocimiento en
diseño de sistemas embebidos, desarrollo aplicaciones para
dispositivos móviles, desarrollo de aplicaciones para PC y
diseño de sistemas de gran escala para internet. Es un
emprendedor serial que previamente co-fundó dos
compañías y es el fundador y principal desarrollador de
Raspbian, el principal SO para la Raspberry Pi.
17
 ¿Te gustaría obtener más potencia de Pi?
¡Ve por el Turbo!
Los procesadores de las Raspberry Pi tienen
una velocidad de reloj de 700Mhz. Esto
significa que realizan 700.000.000 ciclos por
segundo. La velocidad de reloj de un
procesador es un indicador de cuán rápido
puede realizar operaciones. Se mide tanto en
megahertz (Mhz) como en gigahertz (Ghz)
con 1 000Mhz equivaliendo a 1 Ghz. Entonces,
cuantos más Mhz, más rápido operará el
procesador.
¿Qué son el overclock y el overvolt?
Mientras que 700Mhz es la velocidad de
fábrica para el procesador de la Raspberry Pi,
hay formas de obtener un mejor rendimiento...
Overclocking... y gracias a la última versión de
Raspbian, lograrlo es más fácil que nunca!
El Overclocking es el proceso mediante el
cuál se hace funcionar a un componente o
computadora más rápido que su velocidad de
fábrica, sin embargo esto puede implicar un
perjuicio incrementando la inestabilidad y la
vida útil del procesador. Pero para la
Raspberry Pi, estos efectos adversos son tan
insignificantes que ¡serías un tonto si NO
realizas un Overclocking!
El Overclocking también requiere energía
adicional. Si quieres llevar la velocidad de
tu Raspberry Pi a 900Mhz y más,
necesitarás proveerle de energía adicional
a través del “Overvolting”. Cuan lejos
puedes llegar con el Overclock depende
de varios factores; tu Raspberry Pi, la
calidad de tu fuente de energía y
posiblemente también de tu memoria SD.
Debido a la tolerancia de fabricación, el
fabricante garantiza el mejor rendimiento
en 700Mhz. Pero cada Raspberry Pi es
diferente y por lo tanto cada una tiene
límites diferentes.
Existen varias configuraciones de overclock y
overvolt. Estas se encuentran detalladas en
http: //elinux. org/RPi_config. txt#
Overclocking_options aunque la última
imagen de Raspbian contiene una simple
opción de configuración. Lo importante es que
18
esto permite hacer overclock y overvolt de tu
Raspberry Pi sin perder la garantía.
Consideraciones sobre la fuente de energía
Es importante, al hacer overclock, el uso de
una buena fuente de energía. En mi caso
utilizo un cargador para Kindle el cual es de
alta calidad y provee una potencia de 850mA.
Los cargadores originales de Apple iPhone
también son una buena opción y proveen 1 A
de potencia. Ten cuidado con los cargadores
para iPhone fabricados por terceros. La
Fundación Raspberry Pi ha encontrado que
algunos de estos no funcionan según las
especificaciones.
PRECAUCIÓN: has una copia de respaldo
Antes de comenzar, vale la pena mencionar
que hay una posibilidad de que al hacer
overclock los datos en tu memoria SD se
dañen. Asegurate de tener una copia de
respaldo de cualquier documento importante y
también de tu archivo /boot/config. txt .
La forma más sencilla de hacer esto es
copiando los archivos a una memoria USB o
subiendolos a algún servicio de
almacenamiento online como Dropbox.
Alternativamente podría crear una imagen
completa de la memoria SD utilizando el
mismo programa Win32DiskImager usando
inicialmente para crear la memoria SD con
Raspbian. Esta vez, en lugar de escribir la
memoria SD desde una imagen, creará una
imagen de respaldo leyendo la memoria.
Conecte su memoria SD a un lector de
memorias SD en su computadora con
Windows y ejecute Win32DiskImager. Ingrese
un nombre para dicha imagen y haga click
sobre Read. Cuando el respaldo esté
completo, el tamaño del archivo con la imagen
de respaldo debería ser muy similar al tamaño
de su memoria SD.
Overclocking
Para modificar las configuraciones de
overclock inicie la Raspberry Pi. Desde la
terminal, escriba el comando:
$ sudo raspi-config
Luego debería aparecer una caja azul, como
la mostrada anteriormente. Este es el mismo
menú de configuración que aparece al iniciar
una imagen de Raspbian por primera vez. Lo
primero a hacer será actualizar la herramienta
raspi-config. Utilice las teclas de dirección
para desplazarse hacia abajo y seleccionar la
opción “update”. Espera a que raspi-config se
vea como en su última versión. Una vez que
haya finalizado podemos comenzar con el
overclock.
Ahora desplázate hacia abajo y selecciona
una opción de “overclock”. Al momento
existen cinco opciones para elegir; None
(Ninguna), Modest (Modesta), Medium
(Intermedia), High (Alta) o Turbo.
Usa las flechas de dirección para elegir tu
configuración de overclock preferida. Lo mejor
es comenzar con Turbo para ver si es estable.
Sino intenta con High, seguida de Medium y
luego Modest. Luego de hacer tu elección, sal
de raspi-config y reinicia. Esto último es
necesario para que la nueva configuración se
aplique. Los cambios se graban en el archivo
/boot/config. txt .
¿Acabo de romper mi Pi?
¿Pero qué pasa si mi Raspberry Pi no vuelve
a iniciar? Esto significa que la configuración
de overclock ha excedido los límites
operativos de tu Raspberry Pi, pero no te
preocupes, es fácil de resolver. Primero
desconecta la energía de tu Raspberry Pi,
espera unos segundos y vuelve a conectarla.
Inmediatamente mantén presionada la tecla
<SHIFT> en tu teclado. Observa el texto en tu
pantalla. Verás lo siguiente:
[ ok ] Checking if shift key is held down: Yes.
Not switching scaling governor.
Esto significa que la configuración de
overclock fue ignorada e iniciará con
normalidad. Si has tenido mala suerte, es
posible que el sistema de archivos de tu
memoria SD se haya corrompido y tengas que
restaurar tu imagen de respaldo. Si la has
encendido exitosamente, puedes abrir la
terminal y escribir el comando:
$ sudo raspi-config
Esta vez, al elegir una configuración de
overclock, intenta con una opción menor.
Si operas tu Raspberry Pi vía SSH o algún
otro medio de acceso remoto (headless) y no
puedes mantener presionada la tecla
<SHIFT> durante el inicio, entonces
necesitas modificar la configuración de
overclock manualmente utilizando un lector de
memorias SD en otra computadora.
Querrás editar el archivo
/boot/config. txt . En Linux o
Apple Mac puedes utilizar sus editores
de texto predeterminados. En
Windows resultará extraño editar el
archivo config.txt usando Notepad.
Una mejor alternativa se obtiene
descargando el programa gratuito
TextPad desde
http: //www. textpad. com. Las
entradas que necesitarás modificar
son arm_freq, core_freq,
sdram_freq and over_voltage .
Use the image to the left as a
reference for the values you should
use.
Has seleccionado una configuración de
overclock y la Raspberry Pi parece haber
iniciado nuevamente y sin problemas. ¿Cómo
sabrás si esto será confiable?
Continúa en la siguiente página...
19
 Pruebas de confiabilidad
Hay un par de pruebas que puedes realizar
para determinar si la Raspberry Pi será
confiable. No hay nada divertido en tener un
sistema rápido pero poco confiable. Si tienes
instalado el Quake 3 esto es una buena
prueba para las configuraciones de overclock
del CPU y el GPU. Otra prueba muy fácil que
uso es simplemente realizando un upgrade de
la imagen de Raspbian. Para esto debes
iniciar tu Raspberry Pi, abrir una terminal y
escribir los siguientes comandos:
$ sudo apt-get update
$ sudo apt-get upgrade -y
Esta es una buena prueba de las
configuraciones de overclock de la CPU y la
SDRAM. Dependiendo del número de
actualizaciones esto podría demorar 30
minutos, pero al final tendrías la versión final
del sistema..
Una vez completado, reinicia la Raspberry Pi.
Esta vez querrás prestar especial atención a
los mensajes que aparecerán durante el inicio.
Busca mensajes “mmc” o cualquier tipo de
mensajes relacionado con errores en el
sistema de archivos. Adicionalmente, busca
mensajes [ warn ] (advertencia) y [ fail ]
(falla). El hallazgo de estos mensajes sugiere
debilidades potenciales, por lo que deberías
intentar con la configuración de overclock
menor.
Si cuentas son diferentes memorias SD vale
la pena probar con cada una. He probado tres
Raspberry Pis con nueve memorias SD
diferentes, en un rango de velocidades desde
Clase 2 hasta Clase 1 0. Cada Raspberry Pi
era Revisión 1 con USB polyfuses
reemplazados por conexiones cableadas.
Recibieron energía desde el mismo
concentrador USB el cual tuvo una fuente de
energía de 2A. Una de las Raspberry Pi
funcionó correctamente hasta la configuración
de overclock Medium; los otros dos lograron
hasta la configuración High. Pero ninguno de
los tres Raspberry Pi lograron pasar la prueba
de confiabilidad funcionando con la
configuración Turbo.
Lo interesante fue que las dos Raspberry Pis
que lograron funcionar con la configuración
High, solo lo hicieron con siete de las 9
memorias SD. Fallaron con dos de las
memorias; una Trascend 4GB Clase 6 y una
Lexar 1 6GB Clase 6. Sin embargo, tus
resultados podrían ser diferentes.
20
Monitoreo
Al hacer overclock es muy útil conocer al
momento la frecuencia y la temperatura de la
CPU. Puedes hacer esto fácilmente en LXDE.
Haciendo Click-derecho sobre la barra de
tareas en la parte inferior de la pantalla y
seleccionando Add / Remove Panel
Items (Agregar / Quitar Items del Panel). La
ventana de Panel Preferences (Preferencias
del Panel) aparecerá y la solapa Panel
Applets debería estar seleccionada. Has Click
sobre el botón Add (Agregar). Selecciona
CPUFreq frontend y has Click sobre el
botón Add. Repite este proceso pero esta vez
seleccionando Temperature Monitor .
Podrás encontrar útil el agregar otros applets
tales como Volume Control y Network
Status Monitor .
Otro test simple sería iniciar Midori y visitar
http: //www. raspberrypi. org . Mientras
esté cargando, mantén el puntero del mouse
sobre el applet CPUFreq frontend. Verás
el cambio entre 700Mhz y tu configuración
actual de overclock.
Para ver videos sobre overclock además de
otros temas relacionados con la Raspberry Pi,
por favor visita mi canal en YouTube:
http: //www. youtube. com/user/TheRa
spberryPiGuy .
Por Matthew Timmons-Brown
e Ian McAlpine
¿Sabías
qué...?
Mientras ordenaba la edición impresa de
MagPi desde http: //www. modmypi. com,
me enteré que venden un kit de
refrigeración. “The Raspberry Pi Heat Sink
Kit” consta de tres pequeños disipadores
de calor más una cinta térmica, que ayuda
a mejorar la confiabilidad del sistema. Hay
un disipador de calor para el SoC, GPU y
el regulador de energía.
En mis propias pruebas la temperatura de
la CPU cayó desde una máxima de 61 ° C,
sin usar el disipador, hasta una máxima de
sólo 52° C con el disipador de calor.
 E V O L UC I Ó N - P I
El ritmo de desarrollo alrededor de la Raspberry Pi es difícil
de mantener...
Si fuiste de los primeros en tener una Raspberry Pi, lo
más probable es que hayas empezado con “Debian
Squeeze”, un sistema operativo basado en Linux.
Pasaste tiempo aprendiendo como descargar la
imagen, y grabarla en una tarjeta SD. Entonces
probablemente fuiste introducido a LXDE, la interfaz
gráfica liviana x-window. Se veía similar a Windows
pero las cosas eran un poquito diferentes. Tuviste
entonces que aprender a usar un administrador de
paquetes, el comando ‘apt-get’, ‘aptitude’ o quizás
‘synaptic’, para poder descargar e instalar nuevos
paquetes de aplicaciones.
Conseguiste una decente colección de útiles
aplicaciones instaladas, cuando descubriste que hay
una nueva versión de Squeeze disponible, que es
mejor que la anterior, así que empezás todo otra vez.
No mucho después aparece otro sistema operativo,
Debian ‘Wheezy’ Beta. Pero habías escuchado que
hubo algunos problemas con esa versión, y no sabías si
quedarte con Squeeze o pasarte a Wheezy. Fue todo
muy confuso.
Mientras, muchas otras personas todavía esperaban
pacientemente para que su pedido de Raspberry Pi sea
procesado. Finalmente el pequeño paquete llegó y te
pusiste muy feliz. Entonces aprendiste que estaba
disponible una nueva y mejorada versión de la Pi, que
tenía agujeros de montaje y varios otros ajustes, y te
preguntaste si la tuya sería considerada un “viejo
sombrero”. Entonces, para hacer las cosas aún peor,
22
anuncian que la Raspberry Pi vendrá con el doble de
memoria, ¡y por el mismo precio!
Finalmente llega un mejor versión de Wheezy, pero
ahora se convirtió en algo llamado ‘Raspbian Wheezy’,
que es mucho más rápida, y tiene muchos bugs
solucionados. Ah, esperá un segundo, llega otra
versión de Raspbian, que es aún más rápida, y me
entero que hay otra versión planeada para ser lanzada
en las próximas semanas.
Ahora, si sos de los que odian los cambios, a este
punto ya estarás golpeando la cabeza contra la pared,
y preguntándote si, después de todo, esto de la
computación es realmente para vos.
En computación las cosas a menudo pasan muy
rápido, y lidiar con el flujo constante de actualizaciones
es algo a lo que te tenés que acostumbrar. Si no
puedes adaptarte al cambio, te vas a quedar atrás.
Probablemente el ritmo de desarrollo irá más lento
hasta cierto punto una vez que los fundamentos estén
en su lugar. Pero nosotros no estamos ahí aún. Podés
esperar, con la versión educacional de la Pi, que las
placas vendrán con una caja incluida, y probablemente
algún tipo de manual de instrucciones, así como una
imagen mejorada, junto con muchos extras. A pesar de
esto, no debemos esperar que las cosas se estanquen
en esa etapa. Una serie de complementos de hardware
y accesorios le seguirán, incluyendo cámaras, pantallas
y otros dispositivos electrónicos que se enchufarán a tu
Pi. Lo más probable es que para ese entonces, tu
actual Raspberry Pi de 256MB y sin caja a la que le
faltan agujeros de montura quede prácticamente sin
valor.
Lo que tenemos que recordar es: El propósito de la Pi
es aprender los principios de programación, o
interconexión, o solo computación general, y aunque
muchas cosas cambian, los principios fundamentales
no. La raspberry Pi es un dispositivo para aprender, y
para experimentar. No es un accesorio de moda o un
gadget de lujo. La Pi es más bien un ítem barato y
desechable. Existe gente que vende su iPhone 4 solo
porque hay un iPhone 5 disponible. Va haber dueños
de Raspberrys Pi que que caigan en esa misma
trampa, pero la gente que más provecho le sacará a su
Pi serán aquellos que dejen de preocuparse por esas
cosas y dediquen más tiempo a jugar con cualquier
versión que tengan, y aprendan de su experiencia.
Con esto en mente, me di cuenta que mi propia
tarjeta SD estaba vencida , y pensé que sería mejor
echar un vistazo a la version Wheezy 1 8/09/201 2 de
Raspbian:
En el número 5, escribí un artículo comparando Debian
Squeeze y Wheezy, y una de las desventajas que
descubrí fue que aunque Wheezy era bastante más
rápida, puntuaba muy pobremente en reproducción
multimedia. Así que decidí que primero vería si algo
habría mejorado en la actualización.
Primero descargué el la imagen zipeada de 439MB
desde http://raspberrypi.org/downloadas. Me tomó
cerca de 45 minutos usando el enlace de descarga
directa desde mi PC con Windows. Entonces, otros 45
minutos para escribir la imagen en la tarjeta SD usando
Win32DiskImager. Tengo una MicroSD clase 4 que es
bastante lenta, pero funciona bien para esto.
Lo próximo fue conectar la tarjeta MicroSD (dentro de
un adaptador a SD normal) en mi Pi y arrancar la
Raspi. hasta la pantalla de configuración .
Curiosamente, esta vez no tuve que cambiar los
valores de overscan para mi monitor (Como siempre
tuve que hacerlo con versiones anteriores de Debian).
Elegí expandir el rootfs así puedo hacer uso de los
1 6gb de la tarjeta. También configuré la zona horaria a
Londres y activé el modo Turbo a 1 000Mhz. Salí del
menú y reinicié.
Después de iniciar sesión, inicié LXDE tipeando ‘startx’.
El escritorio se ve casi idéntico a la versión anterior,
aunque la imagen se ve más definida. Abrí un una
ventana LXTerminal y escribí ‘sudo amixer cset
numid=3 1 ’ para dirigir el audio a la salida analógica.
Después usé ‘sudo apt-get update’ y ‘sudo apt-get
install xine-ui’ para tener Xine. Xine es un reproductor
multimedia que yo había pasado por alto tiempo atrás
(Mientras hacíamos el número 3 de MagPi). Se veía
prometedor, pero era demasiado lento para ser util, y
pensé que quizás con el nuevo SO y el overclock, esta
vez podría funcionar mejor.
Afortunadamente mi nueva Pi finalmente había llegado
de RS Components (Después de 6 meses de espera),
y era capaz de manejar el ‘Modo Turbo’ completo.
Desafortunadamente llegó una semana después de
que saliera la versión de 51 2MB, y además carecía de
agujeros de montura.
Yo tenía una vieja revisión de la Pi que Antiloquax me
había enviado amablemente, pero que no podía
manejar el Modo Turbo. Falló en arrancar y era
inestable en cualquiera de los niveles de overclock..
Xine fue capaz de ejecutarse y reproducir muchos
formatos que testeé, aunque había algo raro al abrir los
archivos. Solo después de clickear el botón ‘play next
chapter >|’ seleccionaba el archivo correcto para
reproducir, de otro modo aparecía el mensaje ‘There is
no MRL’. Xine pudo reproducir av, mp3, mp4, mov así
como wmv, wma y.... mpeg. SI, MPEG, aunque
empezaba a saltar frames si intentaba reproducir un
video a un zoom mayor que el 1 00%. Yo no pagué por
el codec MPEG. Xine fue bastante inestable y con tenia
bugs, sin embargo el reproductor de línea de comando
‘omxplayer’ funcionó mejor, pero soportando menos
formatos. Todavía es una mejora masiva sobre la
versión anterior de Raspbian Wheezy, y creo que ésta
es digna candidata para poner a descansar a Squeeze
de una vez por todas.
Me tomé un descanso con los reproductores
multimedia e instalé Scribus, el programa de
publicación que usamos para hacer la MagPi. Cargué
uno de los documentos de Python Pit del número 6, y
noté que fue considerablemente más rápido gracias al
overclocking. Fue particularmente mejor cambiando
entre capas, haciendo zoom y haciendo click derecho
para mostrar el cuadro de propiedades.
Finalmente instalé unos pocos juegos de arcade:
‘beneth-a-steel-sky’, ‘geki2’m ‘geki3’, ‘pangzero’ y
‘xsoldier’. Todos funcionaron perfectamente.
Distribuciones actualizadas no son necesariamente
mejores en general. A veces es mejor abstenerse de
actualizar hasta que los bugs hayan sido subsanados,
pero enterrar la cabeza en la arena e ignorar la marcha
del progreso es una mala idea también. Siempre
mantente atento a lo que pasa en la comunidad para
evitar perder las actualizaciones buenas y los ajustes
de rendimiento.
Artículo por Jaseman
23
 Making code development faster

Los fundamentos de GNU Make

make es la parte central del armado de paquetes de código compilado y documentación en un sistema Linux. Cuando
ejecutas make , éste lee uno o más archivos de texto, los cuales contienen las dependencias y targets. Los targets son
ejecutados sólo si el archivo no existe o si es más nuevo que el archivo de salida. La sintaxis permite además
múltiples dependencias, de manera que algunos archivos son requeridos para poder construir otros. Comencemos
con un ejemplo

# Crea el archi vo nuevoArchi vo. txt si no est· presente

nuevoArchi vo. txt:
touch nuevoArchi vo. txt

Análogamente a los lenguajes de scripting, los comentarios comienzan con un numeral(#). El target
nuevoArchi vo. txt no tiene espacios o tabs al comienzo de la línea y es seguido por dos puntos(:). Las
dependencias del target pueden ser añadidas luego de los dos puntos. Cada acción viene dada por una línea que
comienza con un tab. Si se utilizan espacios, make generará un error indicándolo.
Por defecto make busca un archivo llamado Makefi l e . Por lo tanto usa nano (described in the issue 3 C cave
article) para crear un archivo llamado Makefi l e que contenga el ejemplo arriba descrito. Entonces tipea make
La primera vez que make es tipeado, ejecuta el target, el cual utiliza el comando touch para crear un archivo vacío
con el nombre indicado. La segunda vez que make es tipeado, encuentra que el archivo existe por lo que ninguna
acción es ejecutada.
Para un ejemplo con múltiples dependencias, puede ser utilizado un pequeño ejemplo en C. En un nuevo directorio
crea tres archivos: mai n. c

#i ncl ude " pri ntStri ng. h"

i nt mai n() {
pri ntStri ng();
return 0;
}

pri ntStri ng. c

#i ncl ude <stdi o. h>

voi d pri ntStri ng() {
pri ntf(" Construi do con make! \n" );
}

pri ntStri ng. h

voi d pri ntStri ng();

24
A continuación, crea un archivo llamado Makefi l e que contenga lo siguiente:

pri ntStri ng: mai n. o pri ntStri ng. o

gcc -o pri ntStri ng mai n. o pri ntStri ng. o

mai n. o:
gcc -c mai n. c

pri ntStri ng. o:

gcc -c pri ntStri ng. c

cl ean:
rm -f *. o

Esta vez tipeando make provocará que cada archivo . c sea compilado en un archivo . o , entonces los archivos . o
son enlazados juntos para formar un ejecutable llamado pri ntStri ng . El target pri ntStri ng es el primer target
del archivo y es por lo tanto el target por defecto. Cuando make es ejecutado chequea que las dependencias de
pri ntStri ng , las cuales son mai n. o y pri ntStri ng. o existan y no sean más nuevas que el target
pri ntStri ng . Si los archivos no existen, entonces el target es ejecutado para generarlos. Cualquier otro target que
no sea el target por defecto puede ser ejecutado tipeando el nombre del target luego del comando make , por ejemplo,
make cl ean

Escribir makefi l es en el cual cada nombre de cada archivo tiene que ser especificado puede ser muy agotador. Por
lo que pueden ser utilizadas variables automáticas en vez de targets específicos.
pri ntIt: mai n. o pri ntStri ng. o
gcc -o $@ $^

%. o: %. c
gcc -c $< -o $@

cl ean:
rm -f *. o

Este Makefi l e hace exactamente las mismas acciones que el definido anteriormente. La variable automática $@ es
el nombre del target, $^ son los nombres de las dependencias y, $< es el nombre del primer pre requisito. Por cada
archivo . o requerido por el target por defecto, make intenta el wildcard %. c . Si el archivo . c no existe make reportará
un error.
Los Wildcards también puede ser utilizados para definir una lista de archivos . c presentes en el directorio de trabajo:
OBJ ECTS = $(patsubst %. c, %. o, $(wi l dcard *. c))

pri ntIt: $(OBJ ECTS)

gcc -o $@ $^

%. o: %. c
gcc -c $< -o $@

Siendo OBJ ECTS una variable. En este caso, todos los archivos . c presentes en el directorio de trabajo son usados
para construir un ejecutable llamado pri ntIt . El comando wi l dcard lista todos los archivos que coincidan con el
patrón *. c . Entonces patsubst remueve el . c y los reemplaza por el . o . El resultado es asignado a la variable
OBJ ECTS . Prueba usando touch para actualizar cada time stamp e intenta volver a ejecutar make y verás lo que
pasa.
Los Makefi l es pueden tener muchas capas de dependencias. Para las distribuciones de software en múltiples
plataformas, los Makefiles son típicamente generados a partir de plantillas (templates) con la herramienta autoconf.
Artículo Original por W. H. Bell
25
 ¡BIENVENIDO AL
CACHE DE C++!
Una introducción al lenguaje de programación C++ - uno de
los más populares utilizados en la actualidad.
El C++ es un lenguaje de programación, como lo son Python o Java. Es un poco más avanzado,
pero es muy popular, muchos videojuegos de la actualidad y muchos otros programas están
escritos en C++. Es rápido y fácilmente portable, lo que significa que el mismo código es
generalmente transferible entre máquinas Linux, Windows y Mac OS. Si usted está listo para el
desafío, ¡siga leyendo!
Pruebe escribiendo lo siguiente:
#i ncl ude <i ostream>
usi ng namespace std;

i nt mai n()
{
//Sal i da de un mensaj e. .
cout << " Hol a, bi enveni do a C++" << endl ;
return 0;
}

Asegúrese de guardarlo como “hola.cpp” - la parte donde dice .cpp indica que es un archivo
fuente de C++.
Después de compilar y ejecutar, usted debe ver impreso en pantalla el mensaje que está entre las
comillas. Pruebe cambiándolo, recompilando y ejecutando y mire lo que sucede. Al principio esto
puede verse bastante desalentador, pero observe debajo y en la siguiente página donde hay una
explicación de los términos desconocidos.
De esta manera hemos escrito nuestro primer programa, ¿cómo
sabemos lo que va a hacer y lo que significa todo?Aquí voy a explicar los
aspectos importantes del programa:
#include <iostream>
Esta es nuestra sentencia de inclusión. Es utilizada para importar librerías las cuales contienen la
información necesaria para entender los comandos que le dan. La librería iostream contiene
información sobre sobre el manejo de entradas y salidas.
int main()
Esta es la función principal. Todos los programas necesitan una función main y todo lo que está
dentro de la función main es ejecutado. Todas las funciones comienzan con ‘{‘ y finalizan con ‘}’.
//Mensaje de salida
En C++, cualquier cosa que comience con ‘//’ es un comentario, y al igual que los comentarios en
otros lenguajes, estos son ignorados por el compilador.
cout y endl
Estos son nuestros comandos. El comando cout le indica al programa que envíe a la salida todo lo
que se encuentra entre ‘<<’ y el ‘>>’. endl simplemente significa salto de línea.

26
;
Algunos lenguajes utilizan estos puntos y comas. Para entenderlo, piense como hace para escribir
en un lenguaje normal como el castellano. Nosotros finalizamos las indicaciones con un punto
final. Esta es una idea similar, cada vez que queremos que el programa pase a realizar algo nuevo
finalizamos con un punto y coma. En consecuencia podemos utilizar los espacios en blanco (que
son los espacios y saltos de línea) como queramos.
return 0;
Hace que el programa entienda que la función main ha finalizado, lo que significa que el programa
ha terminado. Esto hace que se finalice la ejecución pasado este punto.
Con esta información, vamos a pasar a otros ejemplos más. Pruebe lo siguiente:
#i ncl ude <i ostream>
usi ng namespace std;

i nt mai n()
{
//Defi ne 2 vari abl es
i nt a, b;
a = 1;
b = 2;

//Envi a a l a sal i da l a suma de estas vari abl es

cout << " a + b = " << a + b << endl ;
return 0;
}

Aquí, hemos definido dos variables: a y b. Ellas son de tipo int, que significa que son números
enteros. Hemos creado los dos y luego enviaremos a la salida la suma de ambos.
Por supuesto, esto está muy bien, pero la salida siempre será 3 hasta que cambiemos el código,
por lo cual no resulta demasiado útil. En lugar de eso podemos modificar el programa para tomar
el ingreso del usuario y sumarlo. Pruebe esto:
#i ncl ude <i ostream>
usi ng namespace std;

i nt mai n()
{
//Defi ne 2 vari abl es
i nt a, b;

//Sol i ci ta y al macena el i ngreso de datos del usuari o

cout << " Ingrese el pri mer numero: " ;
ci n >> a;

cout << " Ingrese el segundo numero: " ;

ci n >> b;

//Envi a a l a sal i da l a suma de l as vari abl es

cout << a << " + " << b << " = " << a + b << endl ;
return 0;
}

Esto le permitirá obtener el ingreso del usuario y sumar ambos.

Artículo original de Alex Kerr

27
 Bases Defensivas
Este mes vamos a comenzar con algo de “programación
defensiva”; en otras palabras, tratando de escribir un
programa que pueda interceptar errores .
Este convierte un número
desde decimal a la base de
salida, tomando los dígitos
desde la cadena “DIGITS”
(ver siguiente página).

Perdón, los scripts están en un orden raro este mes - ¡el espacio está escaso!

El Script "get_base"
Esta parte del código permite establecer la base
numérica de entrada y de salida para que lo use el
programa. No se permite el ingreso de un número menor
a 2 o mayor a 16. Esto puede ayudar a resolver algunos
resultados realmente extraños (e incorrectos).

¡Acertijo Hexa!
Si sólo DEAD people (gente muerta) entiende
el hexadecimal. ¿Cuanta gente entiende
hexadecimal?
(La respuesta en la siguiente página)

28
Aquí comienza el programa principal.
Después que el script “get_base” tiene las
bases de entrada y salida, el script
“get_number” comprueba que has
ingresado un número válido en la base de
entrada elegida.
El script “get_number” también elabora la
representación decimal (base 10) de su
número, luego está listo para llamar a
“to_base_out”.

Scratch On!
Esta porción significa que si se está
haciendo en base 4 (por ejemplo),
los únicos dígitos permitidos son 0,
1, 2 y 3.

Como Scratch no posee un bloque “x elevado a la

y”, yo estoy utilizando logaritmos:
10 (log x)*y = xy

¿Trabado?
Podés bajar todos los scripts desde:
http://tinyurl.com/Scratchbases

Respuesta al acertijo:
57005 personas entienden el hexadecimal.

29
 El mes anterior El Taller de Python mostró
cómo obtener ajustes de configuración
desde un un archivo de texto externo.
Este mes se presenta una nueva opción.
El uso de argumentos de línea de
comando proporciona un buen control del
programa al momento de su ejecución.

Esta línea usada para renderizar un Pygame utiliza el

módulo argparse de Python:
http://docs.python.org/dev/library/argparse.html
En LXTerminal ejecuta el comando:
python lines.py -h

Esto mostrará todos los argumentos disponibles. Por ejemplo:

python lines.py -s 3 -t 4

generará una figura de mayor tamaño que el

predeterminado (-s 2) y con líneas ligeramente más
densas (-t 5). Experimenta con las opciones disponibles.
# Generador de líneas usando argumentos de línea de comando
# Por Colin Deady - 03 de Octubre de 2012
# coding=UTF-8

import os, pygame, argparse, sys

from pygame.locals import *

# inicialize pygame (para renderizar la imagen)

pygame.init()

# Definición de las 2 funciones a usar:

# 1) fnAppend2Log escribirá una línea en el archivo de registro
def fnAppend2Log( line2write ):
logfile = open('lines.log', 'a')
logfile.write(line2write + '\n')
logfile.close()

# 2) fnPlotLines renderizará un cuarto de la figura.

# Utiliza las coordenadas previas como nuevas coordenadas iniciales
def fnPlotLines(quarter, sX, sY, eX, eY, incSX, incSY, incEX, incEY ):
fnAppend2Log(quarter + ' quarter co-ordinates:')

# calcula y cicla a través de las coordenadas de la línea

for i in range(0,iterations, args.step):
nSX = sX + (incSX * i) # start X
nSY = sY + (incSY * i) # start Y
nEX = eX + (incEX * i) # end X
nEY = eY + (incEY * i) # end Y

# draw dibuja una línea entre el par de coordenadas.

pygame.draw.line(screen,(lineColour),(nSX,nSY),(nEX,nEY),1)

PYTHON VERSIÓN: 2.7.3rc2

PYGAME VERSIÓN: 1 .9.2a0
O.S.: Debian 7

30
 # construye una cadena para el título de la ventana y el archivo de registro
coordText = '('+str(nSX)+','+str(nSY)+')-
('+str(nEX)+','+str(nEY)+')'
# renderiza la imagen por líneas (takes longer)?
if args.renderlines == 'y':
pygame.display.update();
pygame.display.set_caption(coordText)

# escribe coordenadas en el registro

fnAppend2Log(coordText)

# devuelve las coordenadas finales

return (nSX, nSY, nEX, nEY);

# definición de argumentos de línea de comando:

parser = argparse.ArgumentParser(description='Render shape')
parser.add_argument('-s', action='store', dest='scale', type=int,
default=2, help='Render size, default=2, 200x200px)')
parser.add_argument('-t', action='store', dest='step', type=int,
default=5,
help='Lower step values for denser lines (default=5)')
parser.add_argument('-r', action='store', dest='renderlines',
choices=('y','n'), default='y',
help='Render line by line (Y) or finished object (n)')
args = parser.parse_args()

# definición de las variables necesarias

sz = 100*args.scale # tamaño en pixeles horiz x vert de un cuarto de imagen
iterations = sz +5 # número de líneas a renderizar por cuarto
lineColour = 0,0,255 # el color de la línea a dibujar (azul)

# abre una pantalla de pygame en la que dibuja los objetos

# el tamaño de la imagen es dos veces el del objeto a renderizar, porque renderiza 4 cuartos
screen = pygame.display.set_mode([sz*2,sz*2],0,32)

# Dibuja las líneas, cuarto a cuarto, devolviendo los pares de coordenadas

# Las coordenadas iniciales son iguales a las finales, del último cuadro
sx, sy, ex, ey = fnPlotLines('Top left', sz, 0, sz, sz, 0, 1, -1, 0 )
sx, sy, ex, ey = fnPlotLines('Bottom left', ex, ey, sx, sy, 1, 0, 0, 1 )
sx, sy, ex, ey = fnPlotLines('Bottom right', ex, ey, sx, sy, 0, -1, 1, 0 )
sx, sy, ex, ey = fnPlotLines('Top right', ex, ey, sx, sy, -1, 0, 0, -1 )

# si el renderizado línea a línea fue suprimido entonces mostrará la imagen final

if args.renderlines == 'n':
pygame.display.update();

# graba la imagen renderizada en un archivo

pygame.image.save(screen, 'lineimage.png')

# muestra el resultado en 10 segundos

pygame.time.wait(10000)

Trata de añadir un argumento adicional para opcionalmente deshabilitar

la escritura en el archivo de registro. Esto mejorará el tiempo de
renderización. Pista: así como has agregado el argumento necesitarás
agregar dos estructuras IF ya que el registro será escrito por dos partes
diferentes del código.
Algunas otras ideas para argumentos de línea de comando:
- permitir al usuario que indique un nombre de archivo para la imagen de salida
- Especificar los colores de fondo y de las líneas a partir de una lista predefinida
(negro, blanco, rojo, verde, azul)
- Tener un modo de demostración que cicle el código, permitiendo mostrar
muchas imágenes con colores aleatorios
31
 Tiempo de preguntas y comentarios
P: ¿En relación con los artículos
del Skutter, Uds. mencionan que
puede montarse un brazo
robótico. Podrían por favor
especificar cuál brazo robótico y
dónde puedo conseguirlo?
Richard
R: Skutter es una larga serie de
artículos. El primero de ellos fue
publicado en la edición No.1 de
MagPi y en él damos alguna
información al respecto: "El kit
para el brazo robótico llamado
OWI Edge está actualmente
disponible en Maplin electronics y
emplea una simple interfaz USB
para controlarlo."
http://www.maplin.co.uk/robotic-
arm-kit-with-usb-pc-interface-
266257
P: ¿Será posible ver el magazín
en un iPad en el futuro cercano o
definitivamente no será posible?
John
Gracias por hacer una versión
impresa de MagPi (disponible en
http://www.modmypi.com). Yo
siempre había impreso cada
ejemplar dado que prefiero leerlo
en papel. Imaginen la sorpresa
cuando descubrí que solo costaba
£2.49 lo cual es mucho más
barato que la impresión de 32
páginas a full color que hacía yo
mismo!
Ian
P: Como usuario nuevo de
Raspberry Pi, estoy muy
interesado en su excelente
magazín. No he tenido mayor
dificultad en leer las ediciones
desde la No.1 hasta la No.6 en mi
computador desktop que usa
Linux Mint 13. Imagínense mi
decepción cuando encontré que
de esas 6 ediciones, sólo la
edición No.3 podía ser abierta en
mi Raspberry Pi. No estoy
familiarizado con el programa
MuPDF que usa Raspbian, así
que pensé que lo mejor era
instalar y probar con el MuPDF
en mi maquina con Linux Mint. El
resultado es que cada edición de
MagPi abre perfectamente bien
usando MuPDF en mi máquina
con Linux. Probablemente esto no
sea de su incumbencia técnica,
pero pienso que deberían saber
que un número creciente de
usuarios de Raspberry Pi no
pueden leer su magazín.
Lloyd

R: El site Issuu que usamos sólo R: Este problema se extiende a

recién ha empezado a soportar otros archivos PDF. MuPDF
HTML5, así que ahora debería parece trabajar bien para algunos
trabajar en iPads y en iPhones usuarios y para otros no.
etc. Otra opción es que descargue Personalmente removí MuPDF y
el PDF y lo lea con iBooks. he estado usando xPDF el cual
Actualmente estamos trabajando trabaja bien con todo. Ud. puede
en una versión que sea hacer lo mismo siguiendo estos
independiente de la aplicación de comandos:
visualización. $ sudo apt-get remove MuPDF
$ sudo apt-get install xPDF

editor@themagpi.com
The MagPi is a trademark of The MagPi Ltd. Raspberry Pi is a trademark of the Raspberry Pi foundation. The MagPi magazine is
collaboratively produced by an independent group of Raspberry Pi owners, and is not affiliated in any way with the Raspberry Pi
Foundation. It is prohibited to commercially produce this magazine without authorization from The MagPi Ltd. Printing for non
commercial purposes is agreeable under the Creative Commons license below. The MagPi does not accept ownership or responsibility
for the content or opinions expressed in any of the articles included in this issue. All articles are checked and tested before the release
deadline is met but some faults may remain. The reader is responsible for all consequences, both to software and hardware, following
the implementation of any of the advice or code printed. The MagPi does not claim to own any copyright licenses and all content of the
articles are submitted with the responsibility lying with that of the article writer.
This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a copy of this
license, visit:
http://creativecommons.org/licenses/by-nc-sa/3.0/
Alternatively, send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041 , USA.

32