Mostrando entradas con la etiqueta Intel Galileo. Mostrar todas las entradas
Mostrando entradas con la etiqueta Intel Galileo. Mostrar todas las entradas

domingo, 9 de febrero de 2014

Intel Galileo. Esquema

Hola!! En esta entrada voy a seguir con mi auto-regalo de reyes, la placa Arduino compatible Intel Galileo. En concreto en esta entrada os voy a contar como la gente de Intel, ha solucionado el asunto de las entradas y salidas de la placa Galileo. Pero antes tenemos que ver el problema, para que luego podáis leer la solución.
El problema está muy claro, el SOC de Intel no es capaz de proporcionar a su salida apenas coriente, y menos aún le podemos pedir que nos genere una señal PWM. Además, los procesadores, o el SOC QUARK que monta la Galileo, son integrados puramente digitales, es decir, es impensable, e innecesario, que un procesador digital acepte entradas analógicas. Sin embargo, la gente de Intel, se las ha arreglado para que todo esto sea posible, es decir, tenemos salidas que son capaces de dar hasta 10mA, o absorber hasta 25mA, algo muy superior a los uA que puede dar el procesador. También es posible generar a la salida señales PWM de frecuencia y ciclo de trabajo variable, incluso con esta placa, es posible leer señales analógicas y leer el resultado digital equivalente. 
Para ver como han solucionado, lo primero es ver el diagrama de bloques que nos ofrece Intel sobre su placa.

Lo primero que se ve es que ningún conector de entrada/salida va directamente, sino que pasan antes por unos bloques llamados GPIO PWM, ó ADC ó MUX. Esto ya nos da una idea, y es que existen otros elementos que son los encargados de hacer la faena de los GPIO. Estos elementos se comunican con el QUARK mediante I2C, que si que incorpora el QUARK, al igual que lo hace el ARM de la RPi.
El primero de los bloques que vamos a ver es ADC. Para este bloque, la gente de Intel ha montado en la Galileo un conversor ADC de 12 bits y con comunicación I2C, el AD7298. Este conversor cuenta con 8 entradas single-ended que admiten una entrada de 0 a 2,5 voltios. Para aumentar este rango hasta 5 voltios, lo que hacen es introducir un divisor de tensión en la entrada de forma que pasamos del rango de 0-5 hasta 0-2,5. La velocidad de conversión del ADC es de hasta 1MSPS, un valor realmente algo para tratarse de un conversor con comunicación serie. Para no perder entradas y salidas digitales, cosa que ocurre con las placas Arduino, la gente de Intel permite al usuario que los canales analógicos puedan ser utilizados como entradas o salidas digitales, aunque cabe destacar que esto no es posible hacerlo directamente desde el IDE. Para poder tener 2 tipos de entrada en un mismo PIN, es necesario un conmutador, un multiplexor, a la entrada. Para esta función la gente de Intel ha escogido el TS5A23159, el cual es un multiplexor analógico. la señal de control del multiplexor es comandada directamente desde salidas del QUARK, puesto que son solo señales de control. Pero si vemos el diagrama de arriba nos damos cuenta de que no hay solo un bloque MUX, para que sepamos que multiplexor debemos modificar y en que valor se debe establecer para que a la salida tengamos la señal que deseamos, INTEL nos proporciona este documento, en el cual vemos, en primer lugar que dos señales están a la entrada del multiplexor, que señal del SOC está llevada al pin de control, y que valor corresponde a cada señal de entrada, así pues solo debemos ir siguiendo la señal desde el QUARK hasta la salida, e ir activando o desactivando los "interruptores" necesarios.
Por ultimo, quedan los bloques que aparecen como GPIO PWM. Estos bloques van a ser los encargados de sacar por los pines las señales digitales que deseemos, tanto señales estáticas, como señales PWM. Para esta función se ha elegido un expansor de puertos con comunicación I2C del fabricante CYPRESS, el CY8C9540A. Este integrado proporciona hasta 40 pines de entrada-salida, además de 6 módulos PWM que podemos configurar como deseemos hasta una frecuencia de 93kHz. Este expansor, además de los puertos incorpora también una memoria EEPROM.
Todos estos son los integrados que podemos encontrar en la placa Intel Galileo. En la próxima entrada veremos como controlar todos los periféricos desde la linea de comandos de Linux.

domingo, 19 de enero de 2014

Primeros pasos con la Intel Galileo

Como os comenté en la entrada anterior, hace una semana me llegó la nueva placa Arduino compatible, la Intel Galileo. Esta semana en los ratos libres que he ido teniendo he empezado a hacer cosas con ella, en primer lugar instalar drivers y descargar el nuevo IDE, lo siguiente enviar un sketch para que lo ejecute, y luego comunicarme mediante SSH con la versión de linux que se puede instalar.
Bien, lo primero que tenemos que hacer cuando tenemos la placa, es descargarnos el IDE. Hay que tener en cuenta, que a pesar de ser un IDE como el de Arduino, este no nos vale para programarla, al igual que pasa con el IDE de las placas ChipKit UNO, que aunque es igual, no es el mismo, así que nos vamos a la página de descargas de intel y de ahí descargamos la versión del IDE Arduino 1.5.3 que sea compatible con nuestro sistema operativo. Una vez descargado, lo debemos descomprimir en una carpeta raíz de alguna unidad, por ejemplo C:\Arduino, ya que necesitamos que la ruta sea lo más corta posible para evitar luego problemas.
Una vez descomprimido el IDE, podemos conectar la placa al ordenador. Según pone en los documentos de intel, lo primero que se debe conectar es la alimentación mediante el adaptador que viene con la placa. Una vez alimentada, veremos que se encuende el led de ON, al lado del pulsador de reset, en ese momento la placa empieza a cargar el sistema operativo que en intel llaman Little Linux o SPI-Linux. Este sistema operativo es el que viene instalado por defecto en la memoria FLASH interna de 8Mb de la placa. Una vez el SO se ha cargado, se endenderá el led de USB, justo encima del conector USB Client, y en ese momento ya podemos conectar el USB al PC.
Cuando conectemos el USB, desde el PC nos saldrá el tipico mensaje que nos avisa que se ha detectado un nuevo hardware, y no podrá instalarlo automáticamente, así que nos vamos a Panel de control > Sistema > Administrador de dispositvos, y tendremos un dispositivo llamado Gadget Serial v2.4, hacemos click derecho sobre el y le decimos que queremos actualizar el controlador desde una ubicación específica, en concreto, desde esta ubicación C:\arduino\hardware\arduino\x86\tools, en ese momento empezará a instalar los drivers y nos creará un nuevo puerto COM con el nombre de Galileo.
A partir de este momento ya podemos crear nuestros programas y mandarlos a la placa, pero desde intel, recomiendan que antes que nada actualicemos el firmware interno, cosa que se hace muy fácilmente desde el mismo IDE.

Actualizar el firmware nos llevará unos 6 minutos, y es un proceso en el que solo hay que ir pulsando aceptar y esperar. Una vez actualizado ya podemos empezar a programar nuestra Intel Galileo como si de un Arduino se tratara... salvo por un pequeño inconveniente... desde el IDE no es posible guardar programas en la memoria FLASH de la placa, sino en la RAM, por lo que si mandamos un programa, este solo estará mientras la placa no se quede sin alimentación, en el momento que la desconectemos, el programa se borrará. Esto, que es realmente un gran problema, tiene solución, y la vemos en el próximo paso.
Una vez tenemos preparada la placa para recibir nuestros programas, lo único que tenemos es una placa Arduino UNO un poco cara, así que debemos sacarle más jugo a la Intel Galileo, y este jugo tiene el nombre de Linux.
La Galileo, como ya he dicho, almacenada en su memoria FLASH de 8Mb una versión de Linux llamada SPI-Linux (el nombre viene porque la memoria FLASH se comunica con el procesador por un protocolo SPI), esta versión es una versión muy reducida del sistema operativo, aunque si que nos permite hacer varias cosas como comunicarnos vía terminal RS232 a través del jack de audio para poder activar o desactivar gpio, manejar los PWM o leer los canales ADC. En mi caso, no tengo disponible ningún cable que convierta el jack de audio a RS232, por lo que la única opción de comunicarme con la placa era a través de SSH, que lamentablemente no está disponible en la versión de SPI-Linux, por lo que es necesario descargarse un sistema operativo más completo. Este sistema operativo lo descargamos desde la misma página del IDE, y es el que llama
Para empezar a utilizar esta versión, necesitamos una tarjeta SD formateada en FAT o FAT32, y para evitar problemas, es necesario que el volumen tenga el nombre de BOOTME. Para cambiar el nombre del volumen, abrimos desde inicio cmd.exe como administrador, y ejecutamos diskpart.exe. Luego en la ventana que se nos abrirá introducimos:
   select vol f (siendo f la letra del volumen de la tarjeta SD)
   clean
   create part primary
   active
   format quick label="BOOTME"
   exit
Entonces descomprimimos el archivo que hemos descargado en la raíz de la SD, y una vez copiados introducimos la tarjeta SD en la placa, y conectamos la alimentación. A diferencia de antes, cuando arranquemos la placa, el led SD se pondrá a parpadear indicándonos que está leyendo datos de la SD. Es importante si vamos a comunicarnos con la placa mediante SSH que conectemos el cable de red antes de la alimentación. Una vez la placa ha arrancado, podemos conectarla al PC y entonces cuando enviemos un programa desde el IDE, este se almacena en la SD y se ejecuta cada vez que arranquemos la placa, despues de que se inicie el sistema operativo. En este punto también podemos comunicarnos con la Galileo mediante SSH.

Una vez arrancado el cliente SSH, nos identificamos como root, sin contraseña, y ya estamos dentro de la Intel Galileo, mientras que el sketch se ejecuta. Lo siguiente que podemos hacer manejar puertos y leer canales analógicos desde linux, incluso ejecutar diferentes sketches almacenados en la SD.

sábado, 11 de enero de 2014

Intel Galileo

Hola a todos!! Estas navidades, además de los regalos que me han hecho mis familiares, había decidido hacerme un autoregalo, así que me puse a buscar que autoregalo me gustaría más... en un principio estuve mirando las placas UDOO, las cuales las características son muy buenas, procesador de hasta 6 nucleos, arduino DUE integrado, compatible con sistemas operativos Android y Linux, pero estas placas, para mi, tienen un problema, y es que aunque tengamos 6 o 24 núcleos, si queremos realizar un control con estos procesadores, la velocidad se reduce muchísimo, de hecho la raspberry pi que funciona a 700MHz, la velocidad máxima de ejecución de código de usuario son 4 MHZ, con lo que con un PIC16F tenemos mayor velocidad. Es por eso que están saliendo placas como la UDOO que a parte de llevar el procesador principal, llevan uno secundario mediante el cual ejecutar el código de usuario, en este caso, un Arduino DUE, pero entonces... ¿porque pagar por un procesador de 6 núcleos, si luego voy a utilizar uno que funciona a 80MHz?, lo único que ganamos es que el PC host va integrado en la misma placa, pero quien quiere programar un arduino, o se compra un UDOO, seguro que ya tiene un PC en casa, como es mi caso, así que esa idea no me convencía mucho.
Otra opción era esperarme a la nueva Arduino TRE, pero estoy seguro que será bastante cara en comparación con otras placas, por lo que al final me decidí por la Intel Galileo.



El precio de la placa es similar a la Arduino YUN, pero sus características son mejores, y la principal se encuentra en el procesador, ya que la Galileo monta un procesador x86 de la familia Pentium, con toda la compatibilidad que ello conlleva, por ejemplo, con tarjetas Mini PCI Express, mientras que la ardino YUN monta un chip wifi con un procesador MIPS. En cuanto a memoria, la Galileo canta con 8MBytes de FLASH para almacenar el firmware, de los cuales, entre 256kB y 512kB se utilizan para almacenar el programa de usuario (sketch). Cuanta también con 512kB de memoria SRAM embebida, además de 256MB para el sistema operativo. Admite también tarjetas SDE de hasta 32GB, y tiene un EEPROM de 11KB que es compatible con la librería EEPROM de Arduino. En cuanto al Pin Out se corresponde con el de Arduino UNO r3.
Siguiendo con la comunicaciones, la Galileo cuenta con la tipica UART disponible en los pines 0 y 1 de arduino. Además cuenta con una segunda UART que sale por el jack de 3,5mm. Dispone de 2 puertos USB, al igual que la DUE, uno de CLIENTE y otro de HOST, el primero se utiliza para programar la placa. Además lleva en la misma placa un PHY y un conector RJ45 que funciona con la librería ethernet de Arduino. Se me olvidaba decir que la tarjeta SD también funciona con la librería sd de Arduino.
Lo primero que tenemos que hacer para empezar a utilizar la placa es descargarnos el IDE modificado de Arduino para poder programar placas con procesadores x86 desde aquí. Una vez descargado debemos descomprimirlo en la unidad C, ya que si lo hacemos en otra unidad nos dará un error porque el nombre de la ruta es demasiado largo. Una vez tenemos descargado el IDE, tendremos una carpeta, C:/arduino-1.5.3. Entonces ya podemos conectar la placa, en primer lugar el conector de 5V, y luego el cable USB en el conector mas próximo al RJ45. Cuando lo conectemos, nos dirá que no es posible encontrar el driver, y nos creará en el administrador de dispositivos un dispositivo desconocido de nombra Gadget Serial 2.4, pulsamos el boton derecho sobre este, y actualizamos el driver, y le decimos que queremos instalarlo desde una ubicación determinada, y seleccionamos C:\arduino-1.5.3\hardware\arduino\x86, entonces, una vez instalado nos creará un puerto COM con el nombre GALILEO, y entonces ya podemos programar la placa desde su IDE como si de un Arduino se tratara.
Ahora solo queda empezar a desarrollar aplicaciones! Si estas interesado en esta placa no te pierdas las próximas entradas!