Tutoriales
Instalar Linux y correr aplicaciones C# en la Raspberry Pi
- Detalles
- Categoría: Tutorial
- Publicado el Domingo, 11 Agosto 2013 14:40
- Escrito por Santiago Villafuerte
- Visto: 36289
En este breve tutorial podrás aprender a instalar Linux y a ejecutar aplicaciones escritas en Visual C# 2012 con .Net Framework 4.0 en una Raspberry Pi. No importa que tu Pi esté ejecutando Linux ya que mediante el ambiente Mono se pueden ejecutar los archivos del .Net Framework. Este tutorial se maneja completamente desde Windows. Si tienes dudas o comentarios sobre el tutorial, mándame un mail o un twit.
Items necesarios
+ Una Raspberry Pi de cualquier modelo
+ Tarjeta SD de al menos 4GB
+ Teclado USB (sólo para instalar Debian)
+ Cable de red
+ Cable HDMI (sólo para instalar Debian)
+ Fuente de alimentación de 5V @ 1A (o más) y cable micro USB
Software necesario
+ Debian GNU/Linux 7 (wheezy, Raspbian)
+ Win32 Disk Imager
+ Visual C# 2012 Express Edition (se necesita el .Net Framework 4.0)
+ SSH (Secure Shell), Filezilla, Putty o cualquier otro cliente SSH
+ Advanced IP Scanner
Instalando Debian Linux Wheezy en la Pi
La Raspberry Pi siempre carga el sistema operativo desde la memoria SD. Es posible cambiar su software interno pero debe hacerse por JTAG y además no es necesario. En mi caso he usado el SO Raspbian, la versión más común de Linux para la Pi, y también XBMC para ver películas, pero por ahora usaremos Raspbian (Wheezy) que será útil para desarrollar código en la Pi.
De la sección de Raw Images deberás descargar el archivo para Raspbian "wheezy" y guardarlo en tu pc. También descarga la aplicación Win32 Disk Imager, que servirá para grabar a nivel bajo la imagen que contiene la distro wheezy.
Ya con tu memoria SD insertada en tu pc, abre Win32 Disk Imager y selecciona la unidad que le corresponda. Si no estás seguro de cuál es, abre un explorador de Windows para que selecciones la correcta. Importante: esta aplicación formatea tu memoria SD, así que usa una cuyos archivos ya tengas respaldados o no sean importantes. El archivo que grabarás tendrá extensión .img. En mi caso se llama 2013-07-26-wheezy-raspbian.img, pero tú talvez descargues una imagen más reciente.
Espera a que termine de grabar los datos en tu memoria. No la intentes leer en Windows ya que contiene varias particiones de Linux que no deben modificarse. Retira tu memoria e insértala en tu Pi. Conecta el cable de red a tu Pi y luego a tu router, la salida HDMI a tu monitor y a la Pi, y por último el teclado.
Conecta el cable USB. La Pi comenzará a cargar el SO desde la SD card. Verás que el LED PWR estará encendido y OK estará prendiendo y apagando.
Espera a que termina de cargar y que te pida un login, los datos que debes usar son:
pi login: pi
password: raspberry
La Pi abrirá entonces una aplicación de configuración inicial (raspi-config) para que cambies parámetros como:
+ hostname
+ overclocking (yo lo dejo en 700MHz para no bajar su vida útil)
+ cargar escritorio X al arrancar
+ contraseña de usuario
+ habilitar/deshabilitar SSH
+ configurar la RAM qe usará el chip de video
+ etc.
Es importante que dejes habilitado SSH ya que es más cómodo usar la Pi desde otra computadora. Configura los parámetros de la Pi como mejor te convenga. Si deseas volver a entrar a esta configuración inicial, basta con que escribas en la consola:
pi@raspberrypi:~$ sudo raspi-config
Una vez reiniciada tu Pi, ésta volverá a pedirte tu contraseña y estará lista para usarse. El siguiente paso será conectarse a ella por Secure Shell por lo que ya no hará falta tener conectado un teclado ni el cable HDMI.
Antes de eso puedes verificar que el tamaño de tu SD card esté siendo usado correctamente, que el file system se haya expandido bien; teclea lo siguiente para ver el uso de la memoria.
pi@raspberrypi:~$ df
Te reportará lo siguiente:
Filesystem 1K-blocks Used Available Use% Mounted on
rootfs 1873752 1543488 235832 87% /
/dev/root 1873752 1543488 235832 87% /
devtmpfs 86184 0 86184 0% /dev
tmpfs 18888 212 18676 2% /run
tmpfs 5120 0 5120 0% /run/lock
tmpfs 37760 0 37760 0% /run/shm
/dev/mmcblk0p1 57288 18888 38400 33% /boot
Conexión remota a la Raspberry Pi
Una vez que tu Pi está corriendo desde la recién formateada SD card y después de que se configuró con raspi-config, ya puedes conectarte a ella por red sin tener que tener un monitor o un teclado USB conectados. Primero hay que averiguar que IP se le asignó. Abre Advanced IP Scanner (ver link en software necesario). Da click en Scan y comenzarán a aparecer los dispositivos que están conectados en tu subred. Busca la Pi en la lista y copia su IP, la podrás encontrar porque en la pestaña de Fabricante aparece su nombre.
Dependiendo de qué cliente SSH hayas descargado, tendrás que abrir una conexión hacia la IP de la Pi. El login y password son los mismos que se usaron anteriormente.
Putty
SSH Secure Shell
Una vez conectado tendrás la consola lista para recibir comandos.
Instalación del Mono Runtime para ejecutar C#
El Mono Runtime es la máquina virtual del .Net Framework diseñada para sistemas operativos Linux. Raspbian cuenta con soporte para el .Net Framework 4.0 a través de Mono. Con este ambiente se podrán ejecutar aplicaciones de consola de C# en Linux sin tener que emularlas.
Ejecuta los siguientes comandos:
pi@raspberrypi:~$ sudo aptitude update
Cuando haya terminado te mostrará los paquetes y releases que actualizó. En mi caso mostró:
Current status: 4 updates [+4], 4 new [+4].
Ejecuta el siguiente comando para descargar Mono.
pi@raspberrypi:~$ sudo aptitude install mono-runtime
Una vez terminado ya podrás correr aplicaciones .Net en tu Raspberry Pi. Creemos un Hello World para verificarlo.
Es importante comentar que la versión de Mono que se instaló sólo soporta el .Net Framework 4.0. Si tu aplicación será escrita en otra versión, tendrás que bajar el runtime completo de Mono. Hazlo con los siguientes comandos.
pi@raspberrypi:~$ sudo apt-get update
pi@raspberrypi:~$ sudo apt-get install mono-complete
Programando un Hola Mundo en C# para Raspberry Pi
Instala Visual C# 2012 en tu equipo Windows. Ábrelo y crea un nuevo proyecto de consola.
En el archivo Program.cs, que contiene la función main() de nuestra aplicación, colocar el siguiente código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace hello_world
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
OperatingSystem os = Environment.OSVersion;
PlatformID pid = os.Platform;
Console.WriteLine("Running on [" + pid.ToString() + "] OS");
}
}
}
Compila el programa con Build. Esto te generará un archivo.exe que podrás encontrar en la carpeta bin/Debug o bin/Release, dependiendo de qué configuración hayas puesto en tu compilación.
Puedes ejecutar el programa en Windows. Su salida será como lo siguiente.
C:\Users\Link\Desktop\raspberry_pi\hello world\hello world\bin\Release>"hello wo
rld.exe"
Hello World!
Running on [Win32NT] OS
Ahora ese mismo programa lo podremos correr en Linux, basta con mover el archivo.exe generado a la Pi. Esto se puede lograr con Filezilla o con la aplicación de archivos de SSH Secure Shell. Con Filezilla basta configurar lo siguiente para conectarte al File System de tu Raspberry Pi.
Con SSH Secure Shell, la configuración es exactamente la misma que se usó para SSH. Sólo da click en el ícono de la carpeta 
.
Una vez conectado a tu Pi, simplemente copia el archivo.exe a cualquier directorio, te sugiero que sea en /home/pi/Desktop ya que ese directorio pertenece al usuario default de la Pi. Entra al directorio y verifica que tu archivo esté ahí.
pi@raspberrypi:~$ cd Desktop
pi@raspberrypi:~/Desktop$ ls *.exe
hello world.exe
Por último ejecuta tu archivo con Mono con permisos de super usuario (no siempre hacen falta).
pi@raspberrypi:~/Desktop$ sudo mono "hello world.exe"
Hello World!
Running on [Unix] OS
pi@raspberrypi:~/Desktop$
Como te habrás dado cuenta, los ensamblados del .Net Framework son como los de Java, deben poder correr en cualquier equipo donde su correspondiente máquina virtual esté corriendo.
He hecho algunas pruebas con aplicaciones visuales pero no funcionan correctamente como en otros SO como Ubuntu para PC.
En la siguiente sección de curso te daré algunos links útiles para echar a andar los periféricos SPI, UART, I2C, GPIO que trae tu Pi.
Otros recursos útiles para la Pi
RaspberryPiDotNet
Una librería en C# que te permite controlar GPIOs de manera eficiente a través de una librería hecha en C plano. Incluye APIs para LCD Hitachi 44780 (las LCD comunes de siempre) y el ADC MCP3008.
https://github.com/cypherkey/RaspberryPi.Net
Mike McCauley's BCM2835 library
Una librería hecha en C plano que tiene el mejor rendimiento a nivel bajo de los recursos de la Pi. Incluye APIs para controlar SPI, UART, I2C, GPIO que trae tu Pi. Esta es la librería que RaspberryPiDotNet usa para control de GPIOs.
http://www.airspayce.com/mikem/bcm2835/index.html
Corriendo Java en la Raspberry Pi
Un tutorial básico que te indica cómo copiar la máquina virtual de Java para el procesador ARM de la Pi
http://www.geekytheory.com/tutorial-raspberry-pi-11-como-instalar-java/
Comparativo de velocidad de GPIOs en la Pi haciendo uso de varios lenguajes y técnicas de acceso (con C# logré medir 1.5MHz)
http://codeandlife.com/2012/07/03/benchmarking-raspberry-pi-gpio-speed/
Wiring Pi
Una librería pensada en Arduino pero enfocada en la Pi que incluye PWM por software, SPI y otros como UART.
https://projects.drogon.net/raspberry-pi/
Espero que este tutorial te haya ayudado a echar a andar tu Raspberry Pi. Si tienes comentarios o sugerencias por favor mándalos por mail o twitter. ¡Gracias por leerlo!.