N º 0 8 - D IC 2 0 1 2 VisitenuestroKickstarter http://kck.st/TvkdvGpara MagPiimpresas! Una Revista para Usuarios de Raspberry Pi
Atrapa a Papá Noel utilizando la domótica E n est e Gana una Raspberry Pi de 512MB
The MagPi les desea Fe l i z N a v i d a d
E n est e n ú me r o . . .
• S ku t t er • N an p y • P i G au g e • P ib o w • C E S IL P i • C ++ • Ada • M yS Q L • P y t h o n P it
hhttttpp::///wwwwww..tthheem maaggppii..ccoom m Raspberry Pi es una marca registrada de The Raspberry Pi Foundation.
Bienvenidos a la octava edición de la revista The MagPi, ¡Es Navidad! En esta edición esperamos atraerlos con algunos proyectos festivos para probar después de atiborrarnos hasta el borde con pudín de Navidad. En la edición de este mes, presentamos un proyecto de domótica sencillo que le permite controlar luces y aparatos de su casa utilizando el poder de nuestra Pi! Justo a tiempo para atrapar a Papá Noel! Ponemos su proyecto Skutter en marcha con el artículo de Morphy sobre agregar ruedas a la base. Gordon nos enseña cómo iluminar un árbol de Navidad, tenemos más sobre el uso de Pi para controlar un Arduino y Ben describe cómo controlar servomotores conectados al Pi usando Internet! Si esto no es suficiente tenemos más de los viejos favoritos, además de una introducción a SQL. Como siempre, tenemos grandes regalos que puedes ganar en nuestra revista mensual. The MagPi quiere darles nuevamente las gracias a los proveedores de PC que este mes se han superado ofreciendo hasta un Raspberry Pi de 512 MB en juego! Además de esto, este mes te tenemos buenas noticias. A partir del 1 de diciembre, en The MagPi, nos emociona poder ofrecer a nuestros lectores la posibilidad de una versión impresa de los ocho números de la revista! Esto es algo que nos piden constantemente nuestros lectores. Los ocho números serán envueltos prolijamente en una carpeta de edición limitada produciendo un gran regalo para usted o algún ser querido de cualquier edad. Para obtener más información por favor visite (www.kickstarter.com/projects/themagpi/themagpimagazinefromvirtualtoreality) En nombre de todo el equipo, gracias nuevamente por todo su apoyo. Esperamos que tengan una fantástica Navidad y nos vemos en el Nuevo Año (1º de febrero).
Ash Stone Editor Jefe de The MagPi.
2
MagPi team
Redactores Invitados
Ash Stone Editor Jefe / Administrador Chris 'tzj' Stagg Redactor / Fotógrafo / Diseñador Colin Deady Redactor / Diseñador Jason 'Jaseman' Davies Website / Diseñador Matt '0the0judge0' Website / Administrador Meltwater Fotógrafo / Diseñador / Admin. Aaron Shaw Diseñador / Gráficos Ian McAlpine Diseñador / Gráficos Lix Diseñador / Gráficos Sam Marshall Diseñador / Gráficos W. H. Bell Diseñador
Bodge N Hackitt Redactor Geoff Johnson Redactor Andrea Stagi Redactor Ben Schaefer Redactor Gordon Henderson Redactor Alex Kerr Redactor Luke Guest Redactor Richard Wenner Redactor
Contenidos 04 EL RETORNO DEL SKUTTER Sacar la caja de herramientas para la siguiente apasionante instalación, por Bodge N Hackitt 08 AUTOMATICE SU CASA ATRAPE A PAPÁ NOEL Navidad de los 70 usando el lenguaje de programación CESIL, por Gordon Henderson 11 CONCURSO MENSUAL Gane una Raspberry Pi Model B de 512 Mb, por PC Supplies UK 12 CONTROLA TU ARDUINO CON PYTHON Y RASPBERRY PI La potencia de Raspberry y la simplicidad de Arduino utilizando Nanpy, por Andrea Stagi 14 PI GAUGE Controle servomotores a través de internet, por Ben Schaefer 17 PROMOCIÓN DE LIBROS GETTING STARTED WITH PYTHON El nuevo libro de Simon Monk's cubre el uso básico y avanzado de GPIO con ejemplos en Python. 18 ENTREVISTA A PIBOW Una entrevista con los diseñadores de la carcasa PiBow, por Chris Stagg 20 ARBOL DE NAVIDAD ACCIONADO POR CESIL Christmas from the 70's using the CESIL programming language, by Gordon Henderson 22 BIENVENIDO A LA CACHE DE C++ Utilizando variables y cadenas STL, por Alex Kerr 24 COMENZANDO ADA La segunda entrega de nuestro tutorial de programación Ada, por Lucas A. Guest 26 CAMPAMENTO DE BASES DE DATOS Hinque los dientes en el Lenguaje Estructurado de Consulta (SQL), por Richard Wenner 29 LISTA DE EVENTOS DEL MES Encuentros Raspberry y otros eventos de la comunidad 30 EL TALLER DE PYTHON Creación de múltiples widgets de escritorio, por Colin Deady 32 PREGUNTAS Y COMENTARIOS
3
Agregando un chasis motorizado Dificultad: Avanzado. Un “puente H” de conmutación simple En el artículo pasado observamos algunos medios físicos para añadir motores a un robot y hemos investigado la adaptación de juguetes electrónicos motorizados como recurso potencial para el chasis de un robot. En este artículo comenzaré explicando cómo puedes construir tu propio circuito de control para un motor eléctrico de corriente contínua (DC) y escribir un programa básico para manejarlo. Comenzaremos examinando el motor de corriente contínua estándar que explicamos en el artículo anterior. Para hacer que el motor corra hacia adelante aplicamos una fuente de potencia entre los terminales + y – del mismo, y para que corra en reversa, simplemente intercambiamos los terminales de la fuente en posición inversa. El módulo de control del motor que vamos a construir necesitará ser un circuito que permita realizar electrónicamente dicha conmutación en los terminales de la fuente de alimentación . Esto se puede lograr usando un circuito conocido como ”puente H”.
Parte 2 positivo de la fuente con el positivo del motor mientras que el terminal negativo del motor se conecta a tierra, y el motor corre hacia adelante. Por el contrario, cerrando los interruptores 3 y 4 conectamos la tierra al terminal positivo del motor y el positivo de la fuente al negativo del motor, y éste entonces corre en reversa. Existe una situación potencialmente peligrosa si los interruptores 1 y 4 o 2 y 3 son cerrados al mismo tiempo. Esto puede provocar un cortocircuito entre la fuente y la tierra que puede ser como mínimo muy problemático. Debemos cuidar que esta situación nunca suceda cuando usamos este circuito. En realidad, no podemos usar cuatro interruptores físicos de encendido / apagado de esta manera ya que tenemos que controlar el circuito usando el GPIO de la Raspberry Pi. Existen soluciones electrónicas para esto. Una posibilidad es utilizar relés electromagnéticos para cerrar los interruptores. Sin embargo la Raspberry Pi no es capaz de entregar suficiente potencia desde el GPIO para activar directamente estos relés sin colocar en el medio del camino, al menos un transistor. Esto nos conduce a la segunda posible solución que consiste simplemente en usar algunos transistores como interruptores.
Transistores como interruptores El transistor, podría decirse que es la invención electrónica más importante jamás creada. Su desarrollo es el responsable de todo, desde los reproductores portátiles de música hasta el procesador utilizado en la Raspberry Pi.
Este diagrama muestra una versión simplificada de dicho circuito. Cerrando los interruptores 1 y 2 conectamos el terminal
4
Vamos a utilizar transistores NPN. Estos dispositivos poseen tres terminales llamados base, colector y emisor. Conectando una fuente de potencia a través del colector y el emisor permite que el transistor pueda ser utilizado como interruptor. Sin una conexión en la base, la resistencia interna del transistor es extremadamente alta y el interruptor está apagado. Si aplicamos una corriente en la base del transistor, la resistencia interna se reduce un valor proporcional y una mayor cantidad de corriente puede fluir del colector al emisor. El transistor es capaz de variar su resistencia interna muy rápidamente, decenas de miles de veces por segundo (es ésta característica la que permite a los transistores ser usados como amplificadores). La cantidad de corriente necesaria para afectar la resistencia interna del transistor está definida por una proporción conocida como”ganancia de corriente DC” y se simboliza “h FE”. En nuestro caso queremos suministrar una corriente a la base que haga que la resistencia interna sea igual a cero – justo como un interruptor cerrado. Esto se denomina “estado de saturación del transistor” y existe una ecuación que nos dice la cantidad de corriente que necesitamos aplicar a la base para que esto suceda, IB = IC / hFE
donde Ic es la la corriente en el colector e IB es la corriente en la base. Con el fin de averiguar cual es esta corriente, es necesario medir la corriente consumida por el motor. ¡Esto significa que necesitamos hacer un experimento! Para ello necesitarás tu chasis motorizado (en mi caso es el Big Trak modificado), una fuente de potencia (algunas baterías) y un multímetro. Si no tienes un multímetro todavía, estos son una herramienta esencial para cualquiera que se involucre en electrónica ya que permite tomar un amplio rango de medidas incluyendo voltaje, intensidad de corriente, resistencia, capacitancia y h FE. Los motores de corriente contínua consumen diferente cantidad de corriente bajo diferentes condiciones. Si el motor gira libremente entonces necesitará una cantidad de corriente comparativamente menor. Alternativamente, un motor detenido (un motor que esta un poco impedido de girar) demanda una cantidad de corriente extremadamente alta. Cuanto más trabajo le pidamos al motor, mayor corriente demandará. En nuestro caso vamos a medir
la cantidad de corriente que requiere el motor cuando el chasis del robot está rodando por el suelo. Una manera de obtener esta medida con exactitud es hacer que el chasis ruede por el suelo y medir la corriente que está siendo demandada. Aquí está el método que usé con mi Big Trak: Conecta el multímetro en serie entre la batería/s o fuente de potencia y uno de los motores en el Big Trak.
El segundo motor también debe estar conectado a la fuente de potencia y activo, de otra manera tendremos un solo motor tratando de impulsar el Big Trak y por lo tanto la medida resultara inexacta. De todas maneras solo necesitaremos medir la corriente empleada por uno solo de estos motores idénticos. Añade algo de peso al Big Trak para que se aproxime al peso esperado para el robot terminado. En el caso del Skutter esto incluye añadir el brazo del robot. Completa el circuito entre el motor y las baterías, incluyendo los terminales del multímetro en serie, como se ve en la figura. Mientras el Big Trak rueda por el suelo, toma una medida de la corriente que está demandando el motor. Bajo la carga prevista para el Skutter usando este método, uno de los dos motores del Big Trak necesita una corriente de 2.5 amperios. ATENCIÓN: Cuando se probó con un motor reductor la corriente consumida fue de aproximadamente 20 amperios.
Eligiendo el transistor correcto. Cada transistor tendrá una corriente en el colector; ésta corriente es igual a la corriente demandada por los motores. Esto era 2.5 amperios para el Big Trak (pero obviamente será diferente si estás utilizando otros motores
5
en tu robot). Ahora necesitamos encontrar algunos transistores que funcionarán como interruptores cuando esté pasando esta corriente. Considera una vez más la ecuación de saturación del transistor: I B = I C / h FE Dos de los valores en esta ecuación ya son conocidos. Tenemos 2.5 A para Ic y sabemos que cualquier pin en el GPIO de la Raspberry Pi es capaz de entregar un máximo de 1 5 mA ( o 0.01 5 amperios). Necesitamos averiguar un valor mínimo para hFE (ganancia de corriente) para estos dos valores y esto puede ser realizado reordenando la ecuación: h FE = I C / I B Para que un transistor sea capaz de operar como interruptor de un motor de Big Trak usando el GPIO como disparador esto sería: h FE = 2.5 / 0.01 5 Por lo tanto, un transistor con una ganancia de corriente de al menos 1 67 es necesario. Además, el transistor debe ser capaz de manejar 2.5 amperios. Por períodos muy cortos de tiempo el circuito que diseñamos debe ser también capaz de manejar tanto como 20 amperios que el motor puede demandar si trabaja forzado. Uno de estos transistores es un BCU81 (RS Components 21 7-81 99) que puede manejar una corriente contínua de 3 amperios y tiene una ganancia de corriente mínima (hFE) de 21 0.
Un circuito transistorizado controlador de motores El transistor BCU81 tiene una ganancia de corriente de 21 0. Esto significa que debemos entregarle solo 1 2 miliampérios desde la GPIO: IB = IC / Hfe 2.5 / 21 0 = 0.01 2 Podemos utilizar una resistencia en serie con la salida del GPIO para limitar la corriente y asegurarnos que solo 1 2 mA llegarán al transistor. Para encontrar el valor de dicha resistencia utilizamos la ley de Ohm: Resistencia = Voltaje / Corriente. El GPIO usa 3.3 voltios (referidos como 3v3) entonces podemos usar estos datos para encontrar el valor que necesitamos para la resistencia: 3.3 / 0.01 2 = 275 Ohms. Por lo general se necesita factorizar una posible caída de tensión en esta ecuación, pero como el transistor en estado de saturación no posee caídas de tensión apreciables esto no
6
es necesario y este cálculo en particular es muy simple. Un valor de resistencias disponible comúnmente es, 270 Ohms. Usando este valor en vez de los 275 Ohms antes calculados tiene efectos despreciables sobre la corriente del GPIO, luego por simplicidad es aceptable el uso de dicha resistencia.
Este es entonces un circuito controlador de motor puente H para Raspberry Pi ( hay una advertencia de seguridad que debemos tener sin embargo, toma nota de esto al final del artículo). Hay cuatro diodos agregados que están orientados en sentido inverso al flujo de corriente. Esto es porque un motor de corriente contínua también genera una cantidad de corriente, especialmente cuando es apagado. Esto es conocido como corriente “de retroceso” y puede ser suficientemente alta para dañar el transistor. Teniendo estos diodos con polarización inversa permite el escape en forma segura de cualquier retroceso de corriente. Podés usar este circuito si estás usando el mismo modelo de Big Trak, y si estás utilizando un chasis con motores diferentes, adapta los cálculos descriptos anteriormente y encuentra las resistencias y transistores adecuados. Un aspecto importante de este circuito es que la tierra de la Raspberry Pi se comparte con la tierra de la fuente de potencia de los motores. Teniendo una “tierra común” como esta significa que podemos tener dos dispositivos independientes, que son alimentados con dos fuentes de potencia diferentes, y aún así funcionar electrónicamente en forma conjunta. Finalmente podemos ver que para impulsar el motor hacia adelante debemos encender los
pines 1 y 2 del GPIO, mientras que para que el motor funcione en reversa debemos encender los pines 3 y 4 del GPIO. El artículo “Control de Entrada” en MagPi contiene la información necesaria para programar este comportamiento y si estás construyendo el circuito ¡puedes considerar el diseño del programa como desafío para el mes que viene! Si, como yo, estás construyendo un robot diferente que utiliza dos motores, entonces necesitarás dos circuitos como este, uno para cada motor. Esto significa que en total vas a estar utilizando hasta ocho pines del GPIO lo cual no deja muchas entradas y salidas libres para el resto del robot.
Advertencia de seguridad. En cualquier momento en que los dos motores estén funcionando, habrá cuatro pines del GPIO entregando cada uno 1 2 miliamperios. Esto suma un total de 48 miliamperios. La corriente máxima que puede entregar todo el cabezal GPIO en cualquier momento es de 51 miliamperios. Controlar directamente el puente H desde los pines del GPIO es una situación muy cercana
al límite de seguridad absoluto de operación. Con el fin de utilizar cualquier otra salida será necesario antes configurar todas las salidas del GPIO al puente H en baja para permitir que la corriente sea entregada con seguridad en otra parte. Finalmente, ya que la corriente que puede entregar el GPIO es relativamente baja necesitamos un transistor con un alto valor de ganancia de corriente hFE y que además pueda tolerar 3 amperios. ¡Este tipo de transistores son opciones poco económicas!.
¿Qué sigue ahora? En el próximo artículo voy a describir una técnica que permite incrementar notablemente el número de pines del GPIO de tu Raspberry Pi utilizando un chip de bajo costo llamado MCP23008 y el bus I2C. Este método resuelve el problema de la limitación de corriente y permitirá a tu robot tener muchas más entradas y salidas, además nos permitirá usar transistores más baratos, con valores más bajos de ganancia de corriente hFE en nuestro circuito.
BasicGPIOHBridgeControl.py : #! /usr/bin/python import time import RPi.GPIO as GPIO
#----------------------------IMPORTANT -----------------------------#IF GPIO 0, 1 is "1" THEN GPIO 2, 3 must be "0" ELSE transistor short circuit ! #-------------------------------------------------------------------GPIO.setup(1, GPIO.setup(2, GPIO.setup(3, GPIO.setup(4,
GPIO.OUT) GPIO.OUT) GPIO.OUT) GPIO.OUT)
#Drive motor forwards for 3 seconds GPIO.output(1, True) GPIO.output(2, True) time.sleep(3) #Stop motor GPIO.output(1, False) GPIO.output(2, False) #Drive motor in reverse for 3 seconds GPIO.output(3, True) GPIO.output(4, True) time.sleep(3) #Stop motor GPIO.output(3, False) GPIO.output(4, False)
NOTA: Este programa necesita otro grupo de 4 pines GPIO para controlar un segundo puente H si el robot está usando dos motores.
Artículo por Bodge N Hackitt
7
Automatiza tu casa con una Raspberry Pi... y ¡atrapa a Papá Noel (Santa) en el acto! Este artículo trata una forma fácil de construir, barata, y sobre todo, segura, de controlar dispositivos conectados a la red de alimentación de una casa con una Raspberry Pi. Nada en este proyecto incluye trabajar con voltajes peligrosos. El soldado se limita a unas pocas uniones y el código fuente puede ser descargado desde la parte del software.
tu smartphone para encender la cafetera cuando llegas a tu casa o encender el velador cuando Papa Noel camina sobre un felpudo con sensor de presión en frente de la chimenea en nochebuena?
La historia
poder imitarlos usando la Raspberry Pi. La comunicación entre el control remoto y los enchufes está basada en ondas de radio, permitiendo el control sin línea de visión. Esto permite a los enchufes en varios cuartos ser controlados desde un solo lugar.
Compré unos enchufes a control remoto de http://www.amazon.co.uk (Busca por Status remote control socket).[...] Los probé un par de veces, los dejé en el armario y los olvidé... pero la Raspberry Pi me inspiró a hacer algo útil con ellos. Decidí usar la Raspberry Pi para reemplazar
Descodificando el control remoto El primer paso fue identificar las señales usadas por los enchufes para
En la parte trasera los enchufes tienen una etiqueta que dice 433,92 MHz , así que busqué “receptor 433MHz” en eBay para encontrar un receptor adecuado. Encontré un receptor y transmisor para proyectos con
Arduino por sólo 1 ,6 libras (US$1 .99) incluyendo el envío desde China.
el control remoto y como es programable, podemos extender sus prestaciones. ¿Que te parece encender y apagar las luces del árbol de navidad a horas determinadas, usar
8
Tuve que soldar una antena de 1 7 cm hecha de cable en el receptor y transmisor. El largo de la antena representa a 1 /4 de la longitud de onda de 433,92 MHz. Puedes usar una calculadora online como esta http://www.csgnetwork.com/freqwavelengthc alc.html
Para leer el código del control remoto conecté el módulo receptor a un conector de micrófono de PC. Yo usé una fuente de alimentación externa, pero la Raspberry Pi tiene salida de 5V en los GPIO que sirve igual. La salida del módulo receptor es digital de 5V, que no es adecuada para conectarla directamente a la entrada de micrófono de una PC, así que conecté la salida del módulo, a través de una resistencia de 1 M Ohm a la entrada de micrófono de mi laptop. Yo armé el circuito en una protoboard, pero tú podrías usar el conector del otro extremo del cable de una disquetera como menciono en la sección de Hardware de este mismo artículo.
depende..
Audacity (http://audacity.sourceforge.com) es un excelente freeware (Software libre y gratuito) para examinar señales como esta. Una vez satisfecho con el nivel de entrada, empecé la grabación y presioné uno de los botones en el control remoto. Al detener la grabación me fue posible hacer zoom al área donde se encontraba la señal del control remoto. Esta señal se repetía una y otra vez hasta que el botón era soltado. Los pulsos más cortos parecían ser de cerca de 0.25ms de duración y los más largos hasta el triple.
multitarea y algún otro proceso puede estar usando la CPU en el momento equivocado, mi programa envía la secuencia de bits 1 0 veces con la expectativa de que la última será transmitida correctamente.
De la forma de onda creé esta cadena binaria. Cada bit representa 0.25ms con 1 = pulso alto y 0 = pulso bajo. Para hacerlo más legible cada pulso fue separado con un guión.
Enviando una señal Para poder hacer algo con los datos capturados conecté el transmisor a la Raspberry Pi. El transmisor permanecerá conectado a la Raspberry Pi, así que va ser alimentado por el pin +5V de los GPIO. Yo conecté el GPIO 7 al pin Data y el GND del transmisor al GND del conector GPIO de la Raspberry Pi. Las señales de 3.3V son suficiente para hacer funcionar el transmisor, esto lo descubrí probando. Como Linux es un Sistema Operativo
Cuando ejecuté mi código en la Raspberry Pi por primera vez, capturé la señal con Audacity. Pude ver que la forma de la onda era correcta, pero al revés. Obviamente el enchufe no hizo nada. Invertí todos los bits en el flujo de salida, y volví a ejecutar el código de test ¡Esta vez el enchufe encendió! Ahora solo queda transcribir los otros botones.
Hardware
11111 -000-1 -000-1 -000-1 -000-1 -000-1 -0001 -000-1 -000-1 -0-111 -000-1 -0-111 -000-1 -0001 -0-111 -000-1 -000-1 -0-111 -0-111 -0-111 -0111 -0-111 -000-1 -000-1 -000-1 -0-111111 Esta parte del proyecto es tan solo probar y fijarse. Si llegaste hasta aquí y no puedes encontrar un patrón que se repita cuando aprietas el boton del control remoto, tus enchufes podrían no estar usando las simples señales AM de las que este proyecto
El conector y el cable que usé para los GPIO es de una vieja disquetera de 3 1 /2. Este cable es más ancho que el conector de los GPIO, pero se puede conectar desde una punta dejando que parte del cable sobresalga de la placa. Obviamente esto no
9
será posible si estás usando tu RasPi en una caja. Solo son necesarios 3 cables del GPIO; +5V, GND y GPIO 7 (CE1 ), el pin I controla la transmisión. Del otro lado de mi cable plano hay una pequeña plaqueta. Soldada a esta placa hay un conector para el transmisor hecho a partir de un socket para circuitos integrados.
Software Como el código en el ejemplo que seguí de http://www.elinux.org/Rpi_lowlevel_peripherals accede a la memoria directamente, necesita ser ejecutado como root. Para hacer todo más fácil desarrollé y probé todo como root. Para seguir las instrucciones de aquí en adelante debes hacer lo mismo. Todo se hace desde la línea de comando. A menos que tu RasPi cargue la interfaz gráfica automáticamente, quedate en la línea de comando. Para crear un directorio donde tener el código fuente y el ejecutable mientras lo desarrollamos, tipea lo siguiente: $ mkdir gpio $ cd gpio
Mi código fuente puede ser descargado de http://hogieshouse.com. Solo sigue el link y guarda el archivo en el directorio que acabas de crear. Usa 2 parámetros, el canal y el estado (ON o OFF). Vas a necesitar editar el código para reemplazar mis códigos de control remoto con los del tuyo. Para editar el código escribe: $ nano switch.cpp
Acuerdate de haber quitado las comillas alrededor de los códigos del código fuente. Cuando hayas cambiado los códigos sal presionando CTRL+X, responde con Y para salvar los cambios al archivo y acepta el nombre de switch.cpp. Para crear el ejecutable escribe: $ g++ -o switch switch.cpp
Pruébalo con tus enchufes escribiendo: $ ./switch 1 on
Si funciona, querrás usarlo como cualquier usuario que no sea root. Para hacer eso escribe el siguiente comando: $ chmod +s switch $ mv switch /usr/bin/
Para programar que los enchufes se
10
enciendan y apaguen a horas determinadas debes usar algo llamado cron jobs. Solo escribe: $ crontab –e
ra podrías editar el archivo que controla la programación de tareas. El formato está descrito en el archivo pero para probar algo, agrega las siguientes líneas al final del archivo: 0 * * * * switch 1 on 1 0 * * * * switch 1 off
Esto encenderá el enchufe 1 durante los primeros 1 0 minutos de cada hora. La interfaz no es muy amigable ni de lejos. Una interfaz basada en web sería mucho mejor. Mi interfaz web permite que los 4 canales sean encendidos o apagados, pero no fui tan lejos como para agregar programación. Primero, instala mini-httpd para que actúe como servidor web, Para eso escribe lo siguiente: $ apt-get install mini-httpd
Puedes descargar los archivos para la interfaz web desde http://www.hoagieshouse.com. En el zip se encuentra el archivo config necesario para el mini-httpd y el directorio var/www, que es donde puse la página web y los scripts cgi. No necesitan ninguna modificación, pero si que sean copiados en la locación correcta. El archivo HTML usa una primitiva llamada AJAX para ejecutar el script CGI con el canal y el parámetro on/off. Este script saca los parámetros de la consulta y los usa para llamar al programa que enciende y apaga los enchufes.
Conclusión Ahora que tienes los fundamentos de software para controlar remotamente múltiples enchufes con tu RaspberryPi, te dejo como ejercicio imaginar qué otros activadores podrías conectar a los GPIO para encender y apagar dispositivos. Ah, y si atrapas a Papa Noel por favor decile que me gustaría un paquete de MagPi impresas para navidad: http://www.kickstarter.com/projects/themagpi/ the-magpi-magazine-from-virtual-to-reality. Maplin Parts List VY48C - 433MHz TX/RX £9.99 M1 M - 1 M Ohm resistor £0.29 DG41 U - Floppy disk cable £3.99 Article by Geoff Johnson
CONCURSO DE DICIEMBRE
MagPi y PC Limited estamos muy orgullosos de anunciar un premio muy especial para el ganador del concurso de este mes. ¡El premio de este mes será una nueva Raspberry Pi 51 2Mb Modelo B más una fuente de alimentación de 5V 1 A y una caja para Raspberry Pi de la marca PCSL! Los ganadores del segundo y tercer premio también recibirán una caja para Raspberry Pi de la marca PCSL cada uno. Para participar en el concurso de este de este mes visita la dirección:
http://www.pcslshop.com/info/magpi Fecha de cierre de solicitudes: 20 de diciembre de 201 2. Se informará a los ganadores en el próximo número de la revista y por correo electrónico. ¡Buena suerte!
Para ver la amplia gama de accesorios para Raspberry Pi de la marca PCSL visita http://www.pcslshop.com
¡Los ganadores del mes pasado! Los 5 ganadores de la caja de color frambuesa de PCSL son: Dave Heneghan (Chorley, Reino Unido) , Dean Hutchison (Glasgow, Reino Unido) , Dave Carney (Hartlepool, Reino Unido) , Nigel Laudat (Liverpool, Reino Unido) y Peter Locastro (Derby, Reino
Unido) .
¡Felicitaciones! PCSL le enviará en breve un correo electrónico con los detalles de cómo reclamar todos estos fantásticos premios.
11
Controla tu Arduino con Raspberry Pi y Python El poder de Raspberry y la simplicidad de Arduino utilizando Python y una simple librería: Nanpy. Introducción: Un Arduino puede comunicarse con una Raspberry Pi mediante una conexión serial a través de un puerto USB. Esto crea una interface serial virtual que se utiliza de la misma manera que una interfaz normal, leyendo y escribiendo el archivo de dispositivo serial (serial device file). Para comenzar, conecta tu Arduino y escribe: $dmesg | tail [..]usb 1-1.2: Manufacturer: Arduino[..] [..]cdc_acm 1-1.2:1.0: ttyACM0: USB ACM device[..]
El nodo para mi Arduino Uno es /dev/ttyACM0 y el controlador (driver) es cdc_acm. Todos los Arduinos anteriores con un chip FTDI USB-Serial se acceden via /dev/ttyUSB*: $ls -l /dev/ttyACM* crw-rw---T 1 root dialout 166, 0 Nov 5 00:09 /dev/ttyACM0
Bien, ahora debes agregar tu usuario al grupo “root” para obtener el acceso de lectura/escritura requerido, luego debes reiniciar la sesión para que los cambios tengan efecto. $sudo usermod -a -G dialout TU_USUARIO
Esto es importante porque Nanpy funciona usando este archivo de dispositivo serial. Nanpy es un proyecto open source publicado bajo la licencia MIT y se compone de una parte servidor (flasheada en tu Arduino, en espera por comandos en un serial) y una librería Python pura. Esta librería te permite comunicarte con tu Arduino conectado via USB usando clases y métodos muy similares a los usados en el propio framework de Arduino. Detrás de escena, cuando creas y eliminas un objeto o realizas una llamada a un método con Python, Nanpy comunica vía USB y solicita al server que realice estas operaciones en el Arduino por tí: puedes crear tantas instancias de objetos como quieras sin
12
preocuparte por la liberación de memoria e incluso es posible hacerlo en un contexto multihilo. Nanpy pretende facilitar la vida del programador brindando un instrumento simple, claro y rápido para crear prototipos y scripts interactuando con Arduino con significativo ahorro de tiempo. Para instalar Nanpy lee el archivo README. Necesitas instalar Arduino en tu laptop o Raspberry Pi para construír el firmware. $sudo apt-get install arduino
Nanpy está actualmente en desarrollo y solo fué testeada en Arduino Uno. Puedes descargar Nanpy desde la página de Pypi (http://pypi.python.org/pypi/nanpy) o desde Github (https://github.com/nanpy). Veamos Nanpy en acción intentando encender un LED colocado en el pin 1 3 del Arduino. from nanpy import Arduino Arduino.pinMode(13, Arduino.OUTPUT) Arduino.digitalWrite(13, Arduino.HIGH)
Arduino provee todas las funciones principales, delay, analog/digital write y read. No existen funciones de setup ni loop, solo objetos y llamadas a métodos. De hecho, Nanpy soporta todos los métodos principales de Arduino – LCD, Tone, Stepper y otras librerías. Ahora veremos como usar nuestro display LCD de 1 6x2 conectado a los pines 6,7,8,9,1 0 y 1 1 para escribir un mejor script Hola Mundo. from nanpy import Lcd lcd = Lcd([7, 8, 9, 10, 11, 12],[16, 2]) lcd.printString("Hola Mundo!")
Advertencia: Raspberry Pi puede no proveer suficiente potencia al Arduino en cuyo caso deberás conectar el mismo a una fuente externa.
El mundo exterior.
Ahora te vamos a mostrar como hacer que Arduino se comunique con el mundo exterior
usando la Raspberry Pi. Para entenderlo vamos a construir un moderno reloj con medidor de temperatura, una alarma inicializada vía Bluetooth (utilizando un dispositivo Android en este caso) y con fecha y hora actualizadas a través de un servidor NTP (Network Time Protocol)…
especificando la posición (en filas y columnas) en la que quieres que aparezca en el display. Luego movemos el servomotor como un péndulo una vez por segundo. Podemos actualizar la lectura de temperatura en otro hilo. Leyendo el valor de nuestro sensor de temperatura desde el pin analógico 0 y mostrándolo en el display LCD, cerca del tiempo, cada 60 segundos. temp = ((Arduino.analogRead(0) / 1024.0) * 5.0 - 0.5) * 100 lcd.printString("- %0.1f\xDFC" % temp, 6, 1)
Podés encontrar el proyecto con instrucciones, una aplicación Android y componentes requeridos aquí: https://github.com /nanpy/eggsamples/tree/master/synclock. Para demostrar como funciona Nanpy en un contexto multihilo, este programa crea un hilo para cada funcionalidad, escribiendo todo en el mismo display LCD. En este artículo se muestra solo la parte interna de cada ciclo “while True” presente en cada método “run”, por lo tanto recomiendo que sigas solo con el código fuente. Empecemos con el hilo principal, TimeThread, que toma una lectura de tiempo desde nuestro servidor NTP una vez por segundo y lo almacena en una variable global, milltime: response = ntplib.NTPClient().request( 'europe.pool.ntp.org', version=3) milltime = int(response.tx_time)
Para mostrar fecha y hora en el display LCD se crea un segundo hilo, ShowTimeThread: ... self.servo = Servo(12) ... dt = datetime.fromtimestamp(milltime) lcd.printString(dt.strftime('%Y/%m/%d'), 0, 0) lcd.printString(dt.strftime('%H:%M'), 0, 1) self.servo.write(90 + (30 * self.c)) self.c *= -1
A cada segundo tenemos nuestra variable global milltime, transformada a formato legible y luego impresa en el display LCD. Como puedes ver, printString puede ser llamada
Bien, ahora vamos a ver de qué manera comunicarse con un teléfono Android para configurar la alarma del reloj via Bluetooth. He apareado mi dispositivo con la Raspberry Pi antes de comenzar, sigue las siguientes instrucciones para hacerlo: http://wiki.debian. org/BluetoothUser. Recuerda instalar también python-bluez. Vamos a utilizar AlarmClock, una clase de hilo seguro (thread safe), para salvar en disco y recuperar de allí el valor de alarma del reloj. (ver el código). Luego podemos comenzar nuestra comunicación Bluetooth en un nuevo hilo, AlarmClockThread. ...Bluetooth init and connection... cli_sock, cli_info = srv_sock.accept() cli_sock.send("%d:%d:%d", ck.getAlarm()) try: while True: data = cli_sock.recv(3) if len(data) == 0: break ck.setAlarm(ord(data[0]), ord(data[1]), ord(data[2])) except IOError: pass
Nuestra Raspberry Pi actúa como un servidor, esperando por una conexión bluetooth: una vez que ésta se establece, envía a nuestro dispositivo la alarma de reloj y espera por un nuevo valor para ser almacenado. En el hilo TimeThread comparamos el valor de tiempo actual con el valor de alarma: si estos coinciden, podemos iniciar un nuevo hilo, PlayAlarmThread, que ejecuta una nota Do (C) durante 250 milisegundos, cinco veces, usando una instancia del objeto Tone a través de un parlante conectado al pin digital 4 del Arduino. ¡¡Es hora de levantarse!! Comienza a pensar en tu propio proyecto usando Nanpy, por ejemplo tratando de revivir tu viejo auto radiocontrolado: youtu.be/NI4PDfVMdgM
Artículo por Andrea Stagi
13
PiGauge
DIFICULTAD: fácil-media
Este divertido proyecto muestra cómo controlar los servomotores a través de Internet utilizando un Raspberry Pi. Resúmen
Lista de Materiales
Controlar el hardware que se conecta a la Pi es muy divertido. El control de hardware desde otra ciudad u otro estado que está conectado a la Pi es impresionante.
Aquí hay una lista de los materiales que se necesitan para completar este proyecto:
Controlamos cinco servos, cada servo controla la aguja de un indicador que puede mostrar cualquier dato sobre fondos modulares e imprimibles. Usamos PHP para crear una página web que es servida por la Pi. PHP invoca al sistema a través de la línea de comandos que llama a un programa Python. MIentras tanto, el programa Python controla el movimiento de los servos sobre un bus I2C, devolviendo las posiciones de los servos leyendo los valores de un registro que reside en el controlador de servo. Este, de 1 6 canales, es de Adafruit (http://www.adafruit.com/products/81 5), viene con una buena librería, que se encarga de las operaciones de bajo nivel. Necesita el tutorial para configurarlo inicialmente y descargar la biblioteca. Proporcionamos todo nuestro código, plantillas y on un archivo de ayuda en un repositorio Git. Este proyecto es escalable para controlar hasta 1 6 servos.
Servo Motor
Utilizamos la nueva distribución Debian Wheezy para desarrollar el código en una Raspberry Pi modelo B Rev1 . Se puede utilizar una Rev2 modificando la librería.
Item
Lista de Materiales
Cant. Observaciones
5
Fuente de 4 a 6 volts 1 ServoDriverde16canales 1
Accesorio de Montaje 1
1 80 grados de rotación aprox. 1 00mA por servo I2C Lo hicimos en casa
Adafruit servo driver hoja de datos:
http://www.adafruit.com/datasheets/PCA9685.pdf
Conexión del Hardware Por seguridad, apague su Pi y desenchúfela antes de realizar cualquier conexión. $ sudo shutdown -h now
Primero, conecte los servos. La mayoría de los servos vienen con conectores de acoplamiento pre-instalados. Enchufe el conector en el controlador de servo, asegúrese de que los colores coinciden con la serigrafía. Utilizamos los canales 1 -5. Negro = Tierra Rojo = V+ Amarillo = Señal Pi no puede suministrar suficiente corriente para alimentar los servos. Por lo tanto, se necesita una fuente de alimentación externa. Se utilizó un Adaptador CA de pared de un viejo cargador de teléfono celular de 5 VDC que tenía a mano. Utilice los terminales del controlador de servo para las conexiones de V+ y GND.
14
Sponsored by National Technical Systems Albuquerque Engineering Services http://www.nts.com/locations/albuquerque
Por último, conecte la Pi al controlador del servo. Necesitaremos cuatro conexiones del conector GPIO de la Pi al conector del controlador de servo: 3,3 V, GND, SDA y SCL.
Revise todas las conexiones antes de aplicar tensión. ¡ Cuidado: Los pines Vcc y V + son adyacentes entre sí en el controlador de servo, no los cambies como hicimos nosotros o tendrás un Pi dañado! Conecte su alimentador de pared y encienda su Pi. Si ha conectado todo correctamente, no verá ni olerá humo.
Agregue el dispositivo I 2C al kernel. Reinicie el Pi luego agréguese al grupo I 2C: $ sudo modprobe i2c-dev $ sudo usermod -aG i2c yourusername
Instalar Apache y PHP $ sudo apt-get install apache2 php5 libapache2-modphp5
Para ubicar la IP de su Pi (ej. 1 92.1 68.1 .1 0): $ ip addr inet: ip.of.your.pi
Navegue a http://ip.of.your.pi y debería ver la página "It Works!". Enlace el proyecto PiGauge a la raíz de www: $ cd /var/www $ sudo ln -s /home/pi/PiGauge
Agregue apache al grupo I 2C para que pueda acceder al bus I 2C. A continuación, reinicie apache: $ sudo adduser www-data i2c $ sudo /etc/init.d/apache2 restart
Desde su directorio home:
Descargando Software y Herramientas Aunque no es obligatorio, es una buena idea para mantener su Pi actualizada, empieza con:
$ sudo cp ./Adafruit-Raspberry-Pi-PythonCode/Adafruit_PWM_Servo_Driver/Adafruit_I2C.py /usr/local/lib/python2.7/site-packages/ $ sudo cp ./Adafruit-Raspberry-Pi-PythonCode/Adafruit_PWM_Servo_Driver/Adafruit_PWM_Ser vo_Driver.py /usr/local/lib/python2.7/site-packages/
$ sudo apt-get update && sudo apt-get upgrade
Ya debería estar listo, dirígete http://ip.of.your.pi/PiGauge/ y pruébalo!
Guarde los archivos en el directorio home:
Leyendo la posiciones del Servo
$ sudo apt-get install git $ git clone https://github.com/Thebanjodude/PiGauge
En este fragmento de código agregamos dos bytes sin signo desde el bus I 2C para obtener la posición de un servo.
Descomente todas las líneas de este archivo: $ sudo nano /etc/modprobe.d/raspi-blacklist.conf
a
Continúa en la siguiente página...
15
def print_position(chart_num): chart_pos = (chip.readU8(8 + chart_num * 4) +(chip.readU8(9 + chart_num * 4) sel ect * from i nformati on_schema. CHARACTER_SETS;
Esto produce lo que aparenta ser un lío, y lo es, pero se aprecia algo como esto:
Ahora puede decirle al sistema que use su nueva base de datos, entonce escriba: pr0mpt > use magpi ;
Creando una Tabla Una base de datos puede contener varias tablas según hemos visto. Las tablas necesitan configurarse sólo una vez, pero se debe especificar el tipo de datos y el tamaño de los datos que se espera que contenga. Un comando genérico se observa como esto: pr0mpt > create tabl e ( , , , ........., );
un ejemplo más utilizable:
Todos los carácteres | + y - corresponden a líneas de borde de una tabla en crudo como esta: +---------+---------+---------+----------+---------+----------+ | col_1 | col_2 | col_3 | col_4 | col_5 | col_6 | +---------+---------+---------+----------+---------+----------+ | dato | dato | dato | dato | dato | dato | | dato | dato | dato | dato | dato | dato | +---------+---------+---------+----------+---------+----------+
Ahora puede utilizar describe tabla_aves; para desplegar la ahora familiar descripción: +------------+-------------+------+-----+-------------------+----------------+ | Fi el d
| Type
| Nul l | Key | Defaul t
| Extra
|
+------------+-------------+------+-----+-------------------+----------------+ | PRI | NULL
| auto_i ncrement |
| fi rst_name | varchar(25) | YES
|
| NULL
|
|
| town
| char(30)
| YES
|
| Buenos Ai res
|
|
Creando una Base de Datos
| dob
| date
| YES
|
| NULL
|
|
| bi rds
| i nt
| YES
|
| NULL
|
|
Ahora la parte difícil. MySQL puede volverse muy complejo. Vamos a crear una base de datos llamada magpi. Escriba:
| record
| ti mestamp
| NO
|
| CURRENT_TIMESTAMP |
|
pr0mpt > create database magpi ;
Compruebe si la base de datos ha sido creada: pr0mpt > show databases;
28
pr0mpt > create tabl e tabl a_aves ( i d i nt NOT NULL AUTO_INCREMENT, fi rst_name char(25), town char(30) defaul t " Buenos Ai res" , dob date, bi rds i nt, record ti mestamp defaul t now(), pri mary key (i d) );
| id
| i nt(11)
| NO
+------------+-------------+------+-----+-------------------+----------------+ 6 rows i n set (0. 01 sec)
La próxima vez observaremos cómo insertar datos dentro de tablas pre-cargadas y veremos los datos utilizando ordenamiento, búsqueda y expresiones lógicas.
Artículo Original de Richard Wenner Este artículo se basó en http://pr0mpt.me - un recurso de vídeo gratuito.
(Guía de eventos de MagPi)
¿Quiere estar al día de todos los sucesos sobre Raspberry Pi en su zona? Entonces, esta nueva sección de MagPi es para ti! Nuestro objetivo es listar los eventos Raspberry Jam en su área, proporcionando un calendario RPi para el próximo mes. ¿Está usted a cargo de organizar un evento Raspberry Pi? ¿Deseas publicitarlo? Envíanos un email a:
[email protected]
Raspberry Pi Bloominglabs Meetup Cuándo: El primer martes de cada mes a las 7:00 pm Dónde: Bloomington, Indiana, EE.UU. Las reuniones son el primer martes de cada mes a las 7:00 pm hasta las 9:00 pm, todos son bienvenidos. Más información disponible en http://bloominglabs.org
Manchester Raspberry Jamboree Cuándo: Sábado 09 de marzo 2013 a las 10:00 am Dónde: Sede de la Manchester Central Conference, M2 3GX, UK Se desarrollará desde las 10:00 am hasta las 4:00 pm y hay un número limitado de plazas. Entradas y más información disponible en http://raspberryjamboree.eventbrite.com
Norwich Raspberry Pi User & DEV Group When: Saturday 8th December 2012 @ 12:00pm Where: House Cafe, 52 St. Benedicts Street, Norwich, UK The meeting will run from 12:00pm until 5:00pm. Further information is available at http://norwichrpi.org
CERN Tarte au Framboise Cuándo: Sábado 08 de diciembre 2012 a las 12:00 pm Dónde: House Cafe, 52 St. Benedicts Street, Norwich, UK El encuentro se desarrollará desde las 12:00 pm hasta las 5:00 pm. Más información disponible en http://norwichrpi.org
29
Python puede ejecutar subprocesos que funcionen por separado. Con este enfoque es posible crear cualquier número de widgets de escritorio. Vamos a crear dos widgets: un simple lector de noticias RSS y un downloader para La Foto Astronómica del Día. Ejecuta magpi_widgets.py. Esto iniciará el widget_image.py widgets y widget_rss.py. Un simple CTRL + C en la terminal enviará un comando kill para cada subproceso. Este código requiere algunos módulos adicionales de Python que se puede instalar desde el terminal: sudo aptget install pythonsetuptools sudo easy_install2.7 pip sudo pip install feedparser # analiza RSS sudo pip install beautifulsoup4 # analiza HTML sudo aptget install pythonimagingtk # proporciona el manejo de imágenes
magpi_widgets.py : # Widgets de Python usando pygame y subprocesos # Por ColinD 02 de noviembre 2012 import subprocess, os, signal, Tkinter, time # Ejecutar los subprocesos de widget ¡siéntase libre de añadir más aquí! pImg = subprocess.Popen(["python","widget_image.py"],stdin=subprocess.PIPE) pRss = subprocess.Popen(["python","widget_rss.py"],stdin=subprocess.PIPE) # Enviar el ancho de la pantalla a los subprocesos r = Tkinter.Tk() width = r.winfo_screenwidth() pImg.stdin.write(str(width)+"\n") pRss.stdin.write(str(width)+"\n") # Ejecutar hasta los subrocesos subprocesos terminen por CTRLC try: while True: time.sleep(1) except KeyboardInterrupt: os.kill(pImg.pid, signal.SIGKILL) os.kill(pRss.pid, signal.SIGKILL)
widget_image.py : import urllib, Image, pygame, os, sys, time from bs4 import BeautifulSoup # Leer stdin del proceso padre y calcular la posición del widget de la pantalla baseXPos = int(sys.stdin.readline()) 200 10 os.environ['SDL_VIDEO_WINDOW_POS'] = str(baseXPos) + "," + str(30) # Mostrar una ventana sin bordes para contener la imagen windowSurface = pygame.display.set_mode((200,200), pygame.NOFRAME) while True: try: soup = BeautifulSoup( urllib.urlopen('http://apod.nasa.gov/apod/astropix.html')) # APOD tiene una etiqueta img para que podamos usar find en lugar de findAll imgTag = soup.find('img') imgUrl = imgTag['src']
PYTHON VERSION: 2.7.3rc2 PYGAME VERSION: 1.9.2a0 O.S.: Debian 7
30
imgName = os.path.basename(imgUrl) #Si la imagen ya existe, entonces no volver a descargar if not os.path.exists(imgName): urllib.urlretrieve("http://apod.nasa.gov/apod/"+imgUrl,imgName) # Descargar, cambiar el tamaño y guardar la imagen para el widget imgOriginal = Image.open(imgName) imgResized = imgOriginal.resize((200, 200), Image.NEAREST) imgResized.save(imgName) imgLoad = pygame.image.load(imgName) windowSurface.blit(imgLoad, (0,0)) pygame.display.update() # Si se produce una excepción omitir la descarga en este bucle except (IOError, TypeError, RuntimeError): print "Error downloading, will try again later" # Dormir durante 8 horas ¡ya que no quiero spam en el servidor! time.sleep(28800) widget_rss.py : import pygame, os, sys, feedparser, time pygame.init() # Leer stdin del proceso padre y calcular la posición del widget de la pantalla baseXPos = int(sys.stdin.readline()) 300 10 os.environ['SDL_VIDEO_WINDOW_POS'] = str(baseXPos) + "," + str(430) # Crea la ventana de pygame y rellena el fondo con bloques de color screen = pygame.display.set_mode((300,150)) pygame.draw.rect(screen,(80,140,80),(0,0,300,50)) pygame.draw.rect(screen,(80,80,80),(0,50,300,50)) pygame.draw.rect(screen,(160,160,160),(0,100,300,50)) # Define la fuente para la salida del texto RSS font = pygame.font.SysFont('dejavuserif', 10, True) while True: myFeed = feedparser.parse('http://www.raspberrypi.org/feed') # Hace que el título de la ventana sea el nombre del blog pygame.display.set_caption(myFeed['feed']['title']+" RSS") # Obtener los artículos desde el RSS y la salida del texto for i in range(0, 3): layerText = pygame.Surface(screen.get_size()) outputText = (myFeed['items'][i].title, myFeed['items'][i].updated, myFeed['items'][i].link, myFeed['items'][i].description) # clear the surface each loop by filling with transparent pixels layerText.set_colorkey((0,0,0)) layerText.fill((0,0,0)) j=0 for line in outputText: j = layerText.get_rect().y + j + 5 text = font.render(line.rstrip('\n'), 0, (255,255,255)) textpos = text.get_rect() textpos.x = layerText.get_rect().x + 5 textpos.y = textpos.y+j layerText.blit(text, textpos) screen.blit(layerText, (0, 50*i)) pygame.display.flip() j = j +5 # Dormir durante una hora, ¡evitar el spam en el servidor! time.sleep(3600)
Ideas de mejoras La pantalla de los widgets sólo se actualizará cuando busque nuevos contenidos para descargar, provocando la salida en blanco si se arrastra otra ventana en la parte superior. Trata de usar datetime de Python para determinar cuándo se deben descargar nuevos contenidos, mientras que por separado actualiza la salida de la pantalla cada segundo.
31
El año de The MagPi Me propusieron por primera vez la idea de la revista MAGPI en marzo pasado en los foros de Raspberry Pi después de leer muchos hilos de aquellos novatos en la programación que querían aprender, pero no estaban seguros de cómo empezar o si tenía suficiente experiencia para manejar el Raspberry Pi. En ese momento, no había documentación de cómo utilizar esta pequeña computadora inteligente y la mayoría de los tutoriales y proyectos se orientaron a aquellos con alguna experiencia en el uso de Linux o que tenían experiencia en programación. Sentí que esto podría alejar a un montón de principiantes del aprendizaje de su programación o impedir que se enteraran de la gran variedad de proyectos que serían posibles en la Pi con un esfuerzo limitado. Sentí que faltaba un eje central en la comunidad Raspberry Pi, para orientar al programador más experimentado. Algo que les permitiera, además de los foros, explicar en detalle a los demás cómo replicar sus proyectos, mostrar fotos y videos de casos, y responder a preguntas de la comunidad que ayuden a otros en una situación similar. Viniendo del sector médico con experiencia en la publicación de artículos en revistas, pensé que la mejor forma en que la comunidad puede comunicar su experiencia era crear un lugar
centralizado donde todo el mundo pudiera acceder y compartir la información y los medios en una revista en línea evaluada por colegas, parecía cubrir todo y cumplir con el espíritu educativo de la fundación.
Durante los últimos 8 meses, tanto la revista The MagPi como el equipo han evolucionado. Ahora somos una sociedad de responsabilidad limitada y trabajamos muy de cerca de la Fundación Raspberry Pi.
Animamos a los usuarios a enviar sus proyectos y cargarlos en el borrador de la edición. Los lectores obtienen un primer atisbo de la próxima revista y pueden ofrecer sugerencias para corregir o aclarar lo que está escrito y algunos consejos o trucos que pueden ser beneficiosos.
En la actualidad producimos una revista de 32 páginas mensuales. Nuestro contenido comprende artículos sobre varios temas
[email protected]
acerca de Raspberry Pi, incluyendo la codificación, la robótica, domótica, electrónica y técnicas prácticas por nombrar algunos. Estamos agradecidos por todo el apoyo que nos han dado tanto la Fundación Raspberry Pi como todos nuestros lectores. Nos hemos visto abrumados por la forma positiva en que fuimos recibidos, con una retroalimentación constante que lo refleja y algunos grandes artículos sobre la revista incluyendo aquellos de The Wall Street Journal y de la BBC por Rory Cellan-Jones! Hemos crecido en tamaño como equipo, con editores y colaboradores de todo el mundo, de todas las edades y de todas las profesiones, desde profesores de medicina, técnicos a estudiantes. Para reflejar el interés global en la revista The MagPi se ha traducido al francés y al alemán también se está trabajando en la traducción al chino y al español. Estamos súper emocionados por nuestros planes para el MAGPI en 201 3, incluyendo nuestro proyecto Kickstarter que da a los lectores la oportunidad de conseguir los ocho números en una carpeta de edición limitada. Esperamos que sigan apoyándonos en el nuevo Año. Ash Stone Redactor jefe de The MagPi.
The MagPi es una marca comercial de The MagPi Ltd. Raspberry Pi es una marca registrada de la Fundación Raspberry Pi. La revista The MagPi se produjo en colaboración por un grupo independiente de propietarios de Raspberry Pi, y no está afiliado de ninguna manera con la Fundación Raspberry Pi. Está prohibido producir comercialmente esta revista sin la autorización impresa de The MagPi Ltd. La impresión para fines no comerciales es acordable bajo la licencia Creative Commons indicada abajo. The MagPi no acepta la propiedad o responsabilidad por el contenido ni las opiniones expresadas en cualquiera de los artículos incluidos en este número. Todos los artículos son revisados y probados antes que se cumpla la fecha límite de lanzamiento, pero algunas fallas pueden permanecer. El lector es responsable de todas las consecuencias, tanto para software y hardware, a raíz de la aplicación de cualquiera de los consejos o código impreso. The MagPi no pretende poseer las licencias de derechos de autor y todo el contenido de los artículos son sometidos a la responsabilidad que recae en el escritor del artículo. Este trabajo está licenciado bajo la licenca Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported. Para ver una copia de esta licencia, visite: http://creativecommons.org/licenses/by-nc-sa/3.0/ Alternativamente, envíe una carta a Creative Commons, 444 Castro Street, Suite 900, Mountain
32
