Archive for category Pigmeo
Pigmeo 0.0.2 ya disponible
Resulta que Pigmeo 0.0.1 tenía varios fallos bastante graves y no me había dado cuenta, así que me veo obligado a publicar esta nueva versión que solo arregla esos fallos y no añade mucho más (aunque sí tiene varias cosas nuevas).
Bugs resueltos:
- La compilación no funcionaba correctamente (se requería Mono.Cecil.dll antes de iniciar la compilación, pero el script copiaba el archivo tras la compilación, por lo que daba un error de compilación)
- Pigmeo Compiler no se podía ejecutar en Windows
- La gestión de excepciones descontroladas (unhandled exceptions) no funcionaba correctamente en Windows cuando se utilizaba la interfaz de WinForms. Ahora funciona perfectamente en Windows y en Linux, además lo hace de manera más limpia
Nuevas características:
- Usando Pigmeo Compiler podemos mostrar información sobre un ejecutable de .NET (archivos .exe) antes de compilarlo, tanto desde la consola como desde la interfaz de WinForms
- Cuando salta una excepción desconocida mientras estamos ejecutando la interfaz WinForms, se genera un resumen muy detallado del error y el estado de la aplicación antes de que saltase la excepción, y se permite enviar por e-mail a los desarrolladores
- Se cambió completamente la forma de almacenar los textos de los distintos idiomas. Ahora todo puede traducirse a cualquier idioma mucho más fácilmente
- Añadido un programa de ejemplo escrito en C# y en Visual Basic .NET. El código fuente está acompañado por el .exe y el código en lenguaje ensamblador generado por Pigmeo Compiler
Página de la nueva versión: Pigmeo 0.0.2
Pigmeo 0.0.1 ya disponible
Es una versión alpha, no contiene suficientes características para ser usada para crear casi ningún programa útil.
Sólo necesitas tener instalada una máquina virtual de .NET (CLR), como Mono o Microsoft .NET, y debería funcionar en cualquier sistema operativo para el cual haya disponible un CLR de .NET. Por el momento se ha comprobado que funciona en Linux y en Windows.
Soporta las siguientes características:
- Arquitectura PIC14
- Modelo PIC16F716
- Acceder a variables estáticas definidas tanto en el propio programa como en librerías externas a las que se hace referencia
- Se soportan más de la mitad de los registros disponibles en el PIC16F716
- Forzar al compilador a que llame a ciertas variables de determinada manera, usando el Custom Attribute [AsmName()]
- Forzar al compilador a que almacene ciertas variables en posiciones determinadas de memoria, usando el Custom Attribute [Location()]
- Asignar valores constantes a variables estáticas de tipo uint8/byte
- Copiar variables estáticas de tipo uint8/byte
- Sumar dos variables de tipo uint8/byte
- Sumar dos variables de tipo uint8/byte con comprobación de desbordamiento
- Restar dos variables de tipo uint8/byte
- Bucles infinitos
- Instrucción goto
- Posibilidad de elegir qué hacer cuando el programa termina:
- Quedarse en un bucle infinito sin hacer nada
- Reiniciar el programa
- Posibilidad de elegir cómo implementar el soporte para excepciones:
- No se permiten excepciones
- Terminar el programa cuando salte cualquier excepción
- Interfaz para la línea de comandos
- Interfaz gráfica WinForms
Toda la información sobre esta versión está disponible en http://en.pigmeo.org/wiki/Pigmeo_0.0.1
Compilando código escrito en Visual Basic .NET
Programa de ejemplo escrito en Visual Basic .NET
Código fuente en lenguaje ensamblador generado por Pigmeo Compiler
Y un pantallazo de Pigmeo Compiler compilando este programa desde linux, utilizando la interfaz de WinForms:
Cómo encontrar partes de Pigmeo sin terminar
He preparado un Custom Attribute para que los desarrolladores de Pigmeo puedan marcar métodos/funciones indicando que ese método aún no está implementado, debe ser reescrito o faltan cosas por hacer. Este método se utiliza en el desarrollo de Mono (aunque no he utilizado nada de código de Mono, ni siquiera lo he visto) y me parece útil para encontrar más fácilmente las tareas pendientes pero que no son lo suficientemente importantes o urgentes como para reportarlas como un bug, además de servir como complemento al bugzilla.
En la siguiente imagen podemos ver cómo se marcan las funciones con el atributo PigmeoToDo, que obviamente se compilan y se integran en los metadatos de los ejecutables y las librerías, es decir, los atributos son datos que se almacenan en pigmeo-compiler.exe, Pigmeo.Internal.dll, Pigmeo.dll, PIC16F716.dll… no son variables accesibles desde otras partes del programa.
un método marcado con el Custom Attribute PigmeoToDo
Entonces… ¿cómo sabemos qué métodos poseen el atributo PigmeoToDo?
He implementado una clase (Pigmeo.Internal.FindPigmeoToDos, dentro de la librería Pigmeo.Internal.dll) que puede utilizarse desde cualquier otro programa del proyecto Pigmeo para cargar las librerías y los ejecutables uno a uno y mostrar las funciones marcadas con PigmeoToDo.
De momento el compilador puede llamarse con el parámetro todo o ToDo y conseguimos que el compilador se lea a sí mismo en tiempo de ejecución y nos muestre las cosas que faltan por hacer:
Cómo funciona Pigmeo
(Este artículo es una traducción de How Pigmeo Works, parte de la documentación oficial para desarrolladores de Pigmeo. Al contrario que la documentación para usuarios, la doc. para desarrolladores sólo se publicará en inglés)
Para entender cómo funciona Pigmeo, antes debemos entender cómo funciona .NET.
Cómo funciona .NET
Cuando quieres escribir una aplicación en C#, Visual Basic .NET, C++/CLI o cualquier otro lenguaje de .NET, lo primero que haces es escribir el código fuente. Este código fuente se compila a CIL/IL/MSIL, el lenguaje intermedio de .NET (parecido a otros tipos de lenguaje ensamblador), y se almacena en archivos .exe que contienen bytecodes de CIL (al igual que ocurre en java). Estos bytecodes son representaciones binarias del juego de instrucciones definido por CIL. Cabe destacar que estos archivos .exe no son ejecutables de Windows aunque tengan la misma extensión.
Los bytecodes de CIL almacenados en los ejecutables de .NET (los archivos .exe) se compilan a código máquina por el CLR (cuando el usuario lo ejecuta), la máquina virtual de .NET, y entonces son ejecutados por el procesador. Hay que tener en cuenta que CIL no está orientado a ninguna arquitectura de hardware en particular, por lo que cualquier máquina virtual (CLR) en cualquier arquitectura y cualquier sistema operativo puede compilar y ejecutar los archivos ejecutables de .NET.
Algunas implementaciones de .NET son Mono, la implementación de .NET hecha por Microsoft, DotGNU, Rotor…
Por lo tanto funciona de la siguiente manera:
[C# / VB.NET / C++/CLI / Boo / Chrome / J# / Nemerle / Ruby.NET / IronScheme / IronPython / IKVM.NET / cualquier otro lenguaje que sea compilado a CIL] => compilador => .exe + librerías en el GAC => Máquina Virtual (CLR) => código máquina => procesador
Cómo funciona Pigmeo
Si queremos ejecutar nuestra aplicación en un microcontrolador o algún tipo de sistema embebido, podemos ejecutar un CLR en él y dejar que sea el CLR quien compile y ejecute nuestros bytecodes en CIL (el archivo .exe), como lo hace el .NET Micro Framework, pero requiere muchísimos recursos, así que Pigmeo genera el código máquina en un ordenador común.
Desarrollando aplicaciones en .NET para microcontroladores usando Pigmeo, se escribe el código fuente y se compila a bytecodes de CIL de manera normal. Después Pigmeo Compiler toma el archivo .exe, lo junta con las librerías necesarias y convierte solamente las partes útiles de estos archivos a lenguaje ensamblador para la arquitectura de destino.
Una vez que tenemos nuestra aplicación compilada a lenguaje ensamblador ya podemos utilizar un programa ensamblador para convertirlo a código máquina listo para ser enviado al microcontrolador a través de un programador (como PIC³PROG o PICkit).
Cuando la aplicación haya sido grabada en el microcontrolador ya puede ejecutarse normalmente.
Como resumen:
[C# / VB.NET / C++/CLI / Boo / Chrome / J# / Nemerle / Ruby.NET / IronScheme / IronPython / IKVM.NET / cualquier otro lenguaje que sea compilado a CIL] => compilador => .exe + librerías en el GAC => Pigmeo Compiler => lenguaje ensamblador para la arquitectura de destino => programa ensamblador => código máquina => cualquier programador/grabador de microcontroladores => procesador del microcontrolador
C# 3.0
Para estructurar el código de manera más organizada y sobre todo para poder utilizar extension methods estoy escribiendo el código en C# 3.0. Puede parece algo extraño porque no es demasiado utilizado aún, pero hay partes del framework que no serían nada útiles sin los extension methods. No es mayor problema ya que desde hace bastante tiempo el compilador de mono (mcs/gmcs/smcs) soporta gran parte de C# 3.0 y la última versión ya lo soporta casi todo. La versión de la máquina virtual implementada por Microsoft que los soporta ya hace tiempo que está disponible como descarga para windows y Visual Studio 2008 (en la calle desde el 19 de noviembre de 2007) también permite elegir la versión del lenguaje para la que compilar (incluyendo la 3.0).
No obstante los usuarios finales ni siquiera necesitan instalar una de las últimas versiones de la máquina virtual de .NET (CLR) porque los binarios generados son compatibles con la versión 2.0 ya que las características añadidas a C# 3.0 son sólamente syntactic sugar, aunque quienes quieran utilizar estas funciones añadidas al .NET Framework en sus programas necesitarán una versión actual que lo soporte.
Como ya he comentado, ya principal razón de compilar para C# 3.0 es poder utilizar extension methods, que nos permitirán añadir funciones muy útiles a las clases ya existentes del .NET Framework sin necesidad de reescribir las clases ni sustituir las librerías, por ejemplo podremos hacer “byte a=5; a.Getbit(3);” para obtener el tercer bit de la representación binaria del valor de la variable “a”. Me hubiese gustado poder hacer lo mismo utilizando indizadores, por ejemplo: “byte a=5; a[3];” lo que nos permitiría leer y modificar bits independientes de manera mucho más cómoda. C# 3.0 no soporta extensiones de indizadores ni propiedades pero se espera que C# 4.0 sí lo haga.
Pautas de desarrollo
Antes de que se una cualquier otro desarrollador quiero terminar la estructura principal del proyecto, sobre todo del compilador y el framework, porque son decisiones de diseño y no de implementación, y ese tipo de decisiones prefiero hacerlas sólo ya que de otra manera es mucho más fácil que acabemos discutiendo. Para el final del concurso espero tener terminado el diseño global de compilador y framework, y de momento acabo de terminar las pautas de desarrollo (en inglés) que indican a grandes rasgos cómo se debe escribir el código, más que nada para que sea lo más legible, usable y portable posible, aunque no es demasiado pedante y da bastante libertad al desarrollador.
Supongo que la regla más “incómoda” sea la de documentar casi todo el código fuente con comentarios XML, y documentar absolutamente todas las clases, métodos y variables públicas del framework. Esto es así porque aunque la documentación “real” cueste escribirla, los comentarios en XML son muy útiles para entender el código, y sobre todo el código del framework que va a ser utilizado por los usuarios finales para escribir sus propios programas para microcontroladores. No puedo permitir que un usuario normal quiera utilizar alguna clase incluída en pigmeo-framework y no tenga ni la más mínima idea de cómo utilizarlo. Obligando a los desarrolladores de pigmeo a escribir comentarios XML me aseguro de que cuando un usuario escriba código fuente y su entorno de desarrollo le autocomplete el nombre y los parmámetros de las funciones y variables estos usuarios vean claramente una pequeña descripción de lo que van a utilizar. No hay nada más incómodo que utilizar librerías sin documentar.
Hola Mundo
Mi primer mensaje a dos semanas de comenzar el concurso… que nadie se piense que lo he dejado de lado, es que estos días me ha pillado muy ocupado. Ya he terminado, me he estado organizando y ya está todo listo para empezar. La idea global del desarrollo del proyecto está lista (aunque seguro que cambio bastantes cosas según voy avanzando) y me acabo de registrar en la forja de rediris.
Todo lo que haga (sobre todo la documentación) lo publicaré en la web oficial del proyecto: http://en.pigmeo.org
En http://es.pigmeo.org está la versión en español para más adelante traducirlo todo tranquilamente, pero de momento todo lo publicaré en la web en inglés, tengo que centrarme en picar código y documentar, y no en traducir.
Sobre la forja: intentaré utilizar la menor cantidad de recursos posibles de rediris porque seguramente tras terminar el concurso migre a un sitio más “internacional”. Espero que esto no influya demasiado en la calificación final. Cosas como documentación para usuarios, documentación para desarrolladores, lista extendida de características, enlaces a todas las partes del proyecto (foros, listas de correo…) y demás cosas iran publicadas directamente en el sitio web oficial.
