Python para pics (prueba de concepto)

[diguito_69]

Hola, tengo un proyecto en mente. Como a mi me gusta mucho programar en python, se me cruzo por la cabeza hacer un compilador de python para pics, y empece a programar algo, pero como dije es una prueba de concepto que por ahora lo único que hace es "traducir" la sintaxis de python a c muy basico.

La idea, por ahora, es generar código c para compilarlo con sdcc. Luego, si todo va bien, empezar a generar código asm directamente y compilarlo con gpasm.

Acá va una muestra de lo que hace hasta ahora:

Código python original:

Código: Python

1. import pic18f4455
2. import adc
3. import usart
4. import math.sen
5.  
6. @char
7. def una_funcion():
8.     c = 4
9.     fd = 12
10.     return c + fd
11.  
12. @void
13. def main():
14.     u = 12569
15.     i = 0
16.     while i < 25:
17.         i = i + 5
18.     while 1:
19.         a = 256
20.         b = 26
21.         c = a + b
22.         if c > 100:
23.             a = 100
24.             b = -25
25.         if b < 0:
26.             b = a
27.         read_adc()
28.         pass

Código "traducido" a c:

Código: C

1. #include <pic18f4455.h>
2. #include <adc.h>
3. #include <usart.h>
4. #include <math/sen.h>
5.  
6.  
7. char una_funcion()
8. {
9.     c = 4;
10.     fd = 12;
11.     return c + fd;
12. }
13.  
14.  
15.  
16. void main()
17. {
18.     u = 12569;
19.     i = 0;
20.     while(i < 25)
21.         i = i + 5;
22.     while(1)
23.     {
24.         a = 256;
25.         b = 26;
26.         c = a + b;
27.         if(c > 100)
28.         {
29.             a = 100;
30.             b = -25;
31.         {
32.         if(b < 0)
33.             b = a;
34.         read_adc();
35.         ;
36.     {
37. }

Todavía me falta mucho por hacer, esto es solo una demostración.

Espero sus opiniones.

Saludos.

[diguito_69]

Hola, estuve avanzando un poco con el proyecto y ya puedo generar código compilable por sdcc, un poco limitado pero funciona.

El programita lo unico que hace es hacer parpadear un led (El "hello world" de los pics), faltan muchas cosas por implementar y corregir otras, como los fuses, que actualmente es una cadena que contiene los fuses exactamente igual que en sdcc, la idea es que sea una lista o un diccionario y que el programa lo traduzca para sdcc. Los if y los for no estan implementados, las clases tampoco, no se pueden importar módulos en python, etc.

Código: Python

1. import pic18fregs.h
2. import delay.h
3.  
4. __config__ = """
5. __code char __at __CONFIG1L CONFIG1L = _PLLDIV_NO_DIVIDE__4MHZ_INPUT__1L & _CPUDIV__OSC1_OSC2_SRC___1__96MHZ_PLL_SRC___2__1L & _USBPLL_CLOCK_SRC_FROM_OSC1_OSC2_1L;
6. __code char __at __CONFIG1H CONFIG1H = _OSC_INTOSC__INTOSC_RA6__USB_EC_1H & _FCMEN_OFF_1H & _IESO_OFF_1H;
7. __code char __at __CONFIG2L CONFIG2L = _PUT_ON_2L & _BODEN_ON_2L & _BODENV_2_0V_2L & _VREGEN_OFF_2L;
8. __code char __at __CONFIG2H CONFIG2H = _WDT_DISABLED_CONTROLLED_2H & _WDTPS_1_32768_2H;
9. __code char __at __CONFIG3H CONFIG3H = _CCP2MUX_RC1_3H & _LPT1OSC_OFF_3H & _MCLRE_MCLR_ON_RE3_OFF_3H;
10. __code char __at __CONFIG4L CONFIG4L = _STVR_ON_4L & _LVP_OFF_4L & _ENICPORT_OFF_4L & _ENHCPU_OFF_4L & _BACKBUG_OFF_4L;
11. __code char __at __CONFIG5L CONFIG5L = _CP_0_OFF_5L & _CP_1_OFF_5L & _CP_2_OFF_5L;
12. __code char __at __CONFIG5H CONFIG5H = _CPB_OFF_5H & _CPD_OFF_5H;
13. __code char __at __CONFIG6L CONFIG6L = _WRT_0_OFF_6L & _WRT_1_OFF_6L & _WRT_2_OFF_6L;
14. __code char __at __CONFIG6H CONFIG6H = _WRTC_OFF_6H & _WRTB_OFF_6H & _WRTD_OFF_6H;
15. __code char __at __CONFIG7L CONFIG7L = _EBTR_0_OFF_7L & _EBTR_1_OFF_7L & _EBTR_2_OFF_7L;
16. __code char __at __CONFIG7H CONFIG7H = _EBTRB_OFF_7H;
17. """
18.  
19.  
20. @void
21. def encender_led():
22.     LATCbits.LATC0 = 0
23.  
24.  
25. @void
26. def apagar_led():
27.     LATCbits.LATC0 = 1
28.  
29.  
30. def main():
31.     uint(i)
32.     i = 5
33.     TRISCbits.TRISC0 = 0
34.     LATCbits.LATC0 = 0
35.     while 1:
36.         delay10ktcy(i)
37.         apagar_led()
38.         delay10ktcy(10)
39.         encender_led()

Código: C

1. #include "micropyc.h"
2. #include <pic18fregs.h>
3. #include <delay.h>
4.  
5. __code char __at __CONFIG1L CONFIG1L = _PLLDIV_NO_DIVIDE__4MHZ_INPUT__1L & _CPUDIV__OSC1_OSC2_SRC___1__96MHZ_PLL_SRC___2__1L & _USBPLL_CLOCK_SRC_FROM_OSC1_OSC2_1L;
6. __code char __at __CONFIG1H CONFIG1H = _OSC_INTOSC__INTOSC_RA6__USB_EC_1H & _FCMEN_OFF_1H & _IESO_OFF_1H;
7. __code char __at __CONFIG2L CONFIG2L = _PUT_ON_2L & _BODEN_ON_2L & _BODENV_2_0V_2L & _VREGEN_OFF_2L;
8. __code char __at __CONFIG2H CONFIG2H = _WDT_DISABLED_CONTROLLED_2H & _WDTPS_1_32768_2H;
9. __code char __at __CONFIG3H CONFIG3H = _CCP2MUX_RC1_3H & _LPT1OSC_OFF_3H & _MCLRE_MCLR_ON_RE3_OFF_3H;
10. __code char __at __CONFIG4L CONFIG4L = _STVR_ON_4L & _LVP_OFF_4L & _ENICPORT_OFF_4L & _ENHCPU_OFF_4L & _BACKBUG_OFF_4L;
11. __code char __at __CONFIG5L CONFIG5L = _CP_0_OFF_5L & _CP_1_OFF_5L & _CP_2_OFF_5L;
12. __code char __at __CONFIG5H CONFIG5H = _CPB_OFF_5H & _CPD_OFF_5H;
13. __code char __at __CONFIG6L CONFIG6L = _WRT_0_OFF_6L & _WRT_1_OFF_6L & _WRT_2_OFF_6L;
14. __code char __at __CONFIG6H CONFIG6H = _WRTC_OFF_6H & _WRTB_OFF_6H & _WRTD_OFF_6H;
15. __code char __at __CONFIG7L CONFIG7L = _EBTR_0_OFF_7L & _EBTR_1_OFF_7L & _EBTR_2_OFF_7L;
16. __code char __at __CONFIG7H CONFIG7H = _EBTRB_OFF_7H;
17.  
18.  
19. void encender_led ()
20. {
21.     LATCbits.LATC0 = 0;
22. }
23.  
24. void apagar_led ()
25. {
26.     LATCbits.LATC0 = 1;
27. }
28.  
29. main ()
30. {
31.     uint(i); //Despues de preprocesador queda "unsigned int i;"
32.     i = 5;
33.     TRISCbits.TRISC0 = 0;
34.     LATCbits.LATC0 = 0;
35.     while (1)
36.     {
37.         delay10ktcy(i);
38.         apagar_led();
39.         delay10ktcy(10);
40.         encender_led();
41.     }
42. }

Saludos.

[Picuino]

A mi también me gusta mucho Python. El proyecto me parece muy interesante, sobre todo para acercar la programación de los PICs a los principiantes.

Por desgracia es imposible compilarlo Python por completo. Creo que lo primero que deberías hacer es crear un subconjunto limitado de Python para saber que características tendrá ese TinyPython compilable.

Mucha suerte. Estaré atento a los avances.

Saludos.

[diguito_69]

Si compilar python por completo, es imposible o por lo menos extremadamente difícil tratándose de pics. La idea es principalmente respetar lo que mas se pueda la sintaxis de python.

La librería, los built-in, etc. las voy a dejar de lado y crear unas propias, adecuadas para pics (adc, delay, usart, spi, etc.).

El hecho de no tener que declarar las variables, se puede omitir y declararlas, pero de forma que no rompa esa sintaxis.

Como por ejemplo la función que está en el código de ejemplo "uint(i)" que para python es una función pero la traduzco a c como una declaración de variable "unsigned int i;". Cuando llegue el momento de generar directamente el asm también las traduciré como unsigned int, char, etc. Porque saber el tipo de dato dinámica-mente durante la compilación, creo que generaría mas problemas que soluciones y saberlo durante la ejecución sería muy costoso para el pic.

Espero que se entienda un poco más la idea que tengo para este proyecto.

Saludos.

[Picuino]

Parece que la idea es cambiar la sintaxis del c por la sintaxis en Python.
Yo creo que es una buena idea si la orientas a principiantes, porque la sintaxis de Python es más sencilla.

Las características de programación orientada a objetos se podrían incluir siempre que sean directamente traducibles a c sin muchas complicaciones.
Por ejemplo a mi me gusta mucho la idea de los espacios de nombres separados.

En c se puede declarar:

Código: C

1. int motor1_current = 0;
2.    int motor1_rpm = 0;
3.    int motor2_current = 0;
4.    int motor2_rpm = 0;

Que en Python se podría declarar "dinamicamente" con una inicialización:

Código: Python

1. motor1.current = int(0)
2.    motor1.rpm = int(0);
3.    motor2.current = int(0);
4.    motor1.rpm = int(0);

Que tendría dos espacios de nombres: motor1 y motor2
Cada uno tendría la misma variable (el mismo nombre) pero aplicado a un objeto distinto.


Con los Fuses se puede hacer lo mismo:

Código: Python

1. config.CONFIG1L = _PLLDIV_NO_DIVIDE__4MHZ_INPUT__1L and _CPUDIV__OSC1_OSC2_SRC___1__96MHZ_PLL_SRC___2__1L and _USBPLL_CLOCK_SRC_FROM_OSC1_OSC2_1L

Saludos

[RICHI777]

Felicitaciones por el proyecto !!! Particularmente a mi me gustan esta clases de proyectos, cosas fuera de la común pero que tienen sentido hacerlas. Algunas cuestiones y preguntas, para hacerte.

• El "compilador" de python en que lo estas haciendo ? En Python ?
• Yo te recomiendo que sigas traduciendo a C, para que vayas viendo como se comporta el compilador
• Con respecto a los string que pensas hacer ?

Saludos !

[diguito_69]

Hola, picuino si la idea por ahora es cambiar la sintaxis de c por la de python, las características de programación orientada a objetos pienso incluirlas mas adelante, cuando ya logre traducir bien las cosas mas básicas, como las funciones, asignaciones, operaciones, comparaciones, bucles, etc. Creo que las clases las podría implementar con estructuras y funciones aplicadas a esas estructuras.

RICHI777
    El "compilador" de python en que lo estas haciendo ? En Python ?
        Si lo estoy haciendo en python.

    Yo te recomiendo que sigas traduciendo a C, para que vayas viendo como se comporta el compilador
        Voy a hacer que traduzca a c, mientras voy a ir haciendo pruebas para generar código intermedio y una vez que logre esas dos cosas, que vendría a ser el front-end, ya voy a empezar a trabajar en el back-end que compile el código intermedio, a código de maquina. En realidad acá también va a ser en dos pasos, primero voy a generar asm y ensamblarlo con gpasm, y una vez que logre esto, aunque no me parece algo tan necesario, generar ya el hex listo para grabar.

        Una lista de los pasos que voy a seguir sería esta:

• (1) Traducir la sintaxis de python a c.
• (2) Generar código intermedio.
• (3) Aplicar características de programación orientada a objetos.
• (4) Generar código asm.
• (5) Generar hex.

    Con respecto a los string que pensas hacer ?
        El tema de los string por ahora los estoy dejando de lado, pero traduciéndolo a c, es cuestión de buscar en la librería de sdcc la función correcta para cada situación. Se me va a complicar un poco para cuando me toque generar asm, pero falta mucho todavía como para preocuparme por eso.

Saludos y gracias por interesarse en el proyecto.

[Yeison.Eng]

Muy interesante,
Actualmente estoy involucrado en el proyecto Pinguino y pensé en desarrollar un "traductor" de código Python-Pinguino algo como esta imagen y llegué a la conclusión de que es posible obtener buenos resultados, en mi caso, usando una tarjeta de desarrollo tengo mas fácil la tarea.

Te comento que primero quise utilizar este traductor pero a la final es mas complejo de lo necesario para PICs.

Un proyecto de esta característica necesita restricciones como se plantean en este wiki.

Por el momento no he publicado ningún adelanto, me gustaría saber de algún link en el que pueda estar al tanto de tu desarrollo.

Hasta pronto

[diguito_69]

Hola, por el momento no tengo ningún link para que puedan seguir el desarrollo del proyecto, ya que hasta ahora solo estuve haciendo pruebas, pero todavía no hice nada funcional. Cuando obtenga algo, prometo que lo voy a subir.
Pero antes tendría que ver el tema de las restricciones, voy a leer bien el link de la wiki esa para darme una idea.

Saludos.