ATTO

[Democrito]

Debido a que primero me preguntó Joaquim (hace muchos meses), y ahora Carlos se interesa por el funcionamiento interno del controlador (fase muy beta) que hice del receptor nRF24L01, me he decidido a crear un mini-tutorial sobre el funcionamiento interno de ATTO, a nivel de instrucciones, funcionamiento y adaptaciones hardware.

Programar ATTO es mucho más sencillo de lo que parece. He documentado las 3 primeras instrucciones necesarias para hacer un "hola mundo" de este pequeño microcontrolador, que está especialmente diseñado para manejar protocolos series, como I2C y SPI.

Enlace: https://github.com/Democrito/repositorios/tree/master/Micros/Atto64

Como estoy con varias cosas a la vez, este tutorial lo haré poco a poco.

Saludos.

[Alfredo Carmona Mirats]

Excelente trabajo.

Perfectamente explicado.

He gozado leyendo el contenido de las 3 primeras instrucciones.

Gracias.

--
Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.
Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/52806c79-0afa-4475-bca8-5566036c53d8n%40googlegroups.com.

[Democrito]

Un placer Alfredo, me alegro mucho que lo hayas disfrutado, de eso se trata.

Saludos!

[flip113]

Hola Democrito, felicitarte por el trabajo y la explicación, funciona perfecto, pongo una foto de cómo hice los ejercicios.

[Democrito]

Flip. tienes un 10 ó A+, he probado tu programa.

Habrá un momento del tutorial que comenzarán las curvas. No porque existan instrucciones complicadas (todas son muy sencillas), sino cuando hagamos las adaptaciones hardware para el protocolo SPI o I2C. De todas formas, si alguien no consigue entender esa parte, se queda con el circuito (algo ya hecho) y lo programará sin problemas. La intención es que toméis este pequeño micro y os resuelva de problemas muy complejos, en donde contínuamente hay que tomar decisiones y los paquetes de información son variables en tamaños. Aunque usemos la programación, nada de esto deja de ser electrónica digital. La persona que programa en código máquina comprende y usa el hardware que hay disponible.

Quien quiera seguir todo el tutorial necesitará un analizador lógico y saber utilizar PulseView. De todas formas en el mismo tutorial trataré de explicar cómo usar todo esto.

Saludos!

[charli va]

Está fenomenal Demócrito! este tipo de "mini" micros específicos para hacer taréas concretas está fenomenal.

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/ff9a521d-8606-4f8c-a642-102081244a76n%40googlegroups.com.

[Democrito]

Así es Carlos, llevo tiempo pensando en un pequeño micro que resuelva las salidas tipo a la instrucción"print", que en hardware se hace terriblemente pesado. En fin, hay tanto por hacer!

[charli va]

Yo ando trabajando desde hace tiempo en un micro en esa línea también, más de propósito general pero muy pequeño, aun lo tengo verde pero espero tener pronto alguna versión operativa.

Jesús Arias, liberó un procesador hace tiempo también bastante pequeño, no llegué a probarlo pero tenía muy buena pinta.

El mar, 1 ago 2023 a las 17:04, Democrito (<spo...@gmail.com>) escribió:

Así es Carlos, llevo tiempo pensando en un pequeño micro que resuelva las salidas tipo a la instrucción"print", que en hardware se hace terriblemente pesado. En fin, hay tanto por hacer!

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/28647d1f-2891-469f-9be3-2811ea05d35cn%40googlegroups.com.

[Democrito]

Jesús Arias es un "Master del Universo" que está por aquí silenciosamente. Cada aportación que hace es un verdadero bombazo.Me queda mucho por aprender y experimentar para llegar a ese nivel.

[Democrito]

Instrucción 4ª de 13: Return/ret

https://github.com/Democrito/repositorios/tree/master/Micros/Atto64#01--return-ret

[flip113]

Democrito por lo que entendí el ejercicio que por "dout" salga en secuencia lo siguiente, usando la instrucción "ret" (01) al terminar la temporización:

0x00FF, 0x0000, 0x00AA, 0x0055, y vuelta a empezar.

Quedaría así.

[Democrito]

Está perfecto Flip, también lo he probado y funciona como pedía en el ejercicio.

Muestro tu programa a los demás:

En realidad usar aquí return es ambiguo (ni se gana ni se pierde espacio en la memoria), porque el salto y la temporización miden lo mismo (3 bytes de instrucción), así que sólo vale la pena cuando por ejemplo, el temporizador hubiera sido de más tiempo y se hubiera tenido que añadir otro o varios juntos. Pero de lo que se trataba este ejercicio era de usar el return para familiarizarse con él.

Un abrazo Flip!

[Democrito]

Instrucciones 5ª y 6ª de 13. Carga de un registro de propósito general y salto condicional (saltar si no es igual) :

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#c3--guarda-en-un-registro-de-16-bits-un-valor-concreto-que-puede-ser-utilizado-por-varias-instrucciones

[flip113]

Democrito darte las gracias por todas estas explicaciones, creo que la solución al ejercicio en vez de usar los valores 0 y 255, sustitúyelo por los valores 0 y 170 es esta.

[Democrito]

Eso es Flip! Pondré como solución tu respuesta en github como ya he en los ejercios anteriores. Me quedan tres instrucciones por explicar, y después comenzaremos a usar el analizador lógico, que es para lo que realmente está diseñado este pequeño microcontrolador. Es importante no sólo programar, sino adaptarlo para lo que realmente está hecho. Mientras lo creaba, iba en función de las necesidades, en plan, ahora necesito que haga esto, y ahora esto otro.

Un abrazo Flip!

[Democrito]

Instrucción 7ª: Salto condicional ------------> Si es igual, saltar.

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#83--salto-condicional-------si-es-igual-saltar

[charli va]

Gracias por todo el detalle , muy interesante! va a ser muy didáctico!

El vie, 4 ago 2023 a las 16:14, Democrito (<spo...@gmail.com>) escribió:

Instrucción 7ª: Salto condicional ------------> Si es igual, saltar.

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#83--salto-condicional-------si-es-igual-saltar

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/9ec22012-03f2-4368-91ab-d8c38638e68cn%40googlegroups.com.

[flip113]

Ya tengo ganas de llegar al analizador lógico, dejo el ejercicio Instrucción 7ª: Salto condicional ------------> Si es igual, saltar.

[flip113]

Democrito he observado un fallo en este ejercicio, y es que al pulsar el pulsador varias veces en una de estas se quedan los leds apagados y ya no funciona al volver a pulsar. Tengo dudas si es un problema de programación o es que esta fallando la placa.

[Democrito]

Muy buenas Flip!

Tu respuesta al ejercicio propuesto es perfecta.

Sobre el bug, así es, lo he podido reproducir todas las veces que lo he hecho, unas veces insistiendo más y otras menos. He buscado alguna manera hardware para resolverlo, todas sin éxito. El problema debe de estar en el uC. Luego probé a tratar de resolverlo por software y al parecer queda resuelto añadiendo una temporización (10us) en el salto de vuelta. Te adjunto el ICE modificado por si tú consigues hacerlo fallar.

Me miraré con lupa este bug. La instrucción "83" es una nueva instrucción que metí hace poco. La necesito para cuando diseñe el driver emisor para el nRF24L01. En proyectos antiguos no existe esta instrucción. Probaré con la instrucción "E3" (si no es igual, saltar), a ver si sucede lo mismo.

Muchísimas gracias por avisar!

[Democrito]

Creo que ya está corregido. La entrada "cmp" estaba sin registrar (ese bus entraba directo a lógica combinacional), le he añadido un registro de 8 bits que registra la entrada cuando se ejecuta las instrucciones de comparación "E3" y "83". Este tema pertenece a las reglas de diseño síncrono.

Te adjunto el archivo corregido. Por favor, si te vuelve a salir el bug, avísame! Yo he estado un buen rato intentado que saliera y parece ser que ya no sale.

[flip113]

Democrito eres un fenómeno, ahora funciona perfecto.

[Democrito]

Instrucción 8ª: Bucle "for" para Atto:

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#a3--d3--ejecutar-otras-instrucciones-un-n%C3%BAmero-de-veces-determinado

[flip113]

Hay va el ejercicio de la Instrucción 8ª: Bucle "for" para Atto

Seguimos avanzando.

[Democrito]

Perfecto Flip! continuamos....

[Democrito]

Intrucción 10ª:  F1 // "Return" de la interrupción hardware externa.

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#f1--return-de-la-interrupci%C3%B3n-hardware-externa

[Democrito]

Instrucción 11ª: Carga un valor externo dentro de la memoria:

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#b3--guardar-un-valor-externo-dentro-de-la-memoria

En las dos siguientes instrucción ya usaremos el protocolo SPI e I2C.

[flip113]

Dejo el ejercicio sencillo de Instrucción 10ª:  F1 // "Return" de la interrupción hardware externa.

[Democrito]

Adjunto la solución al ejercicio 7, instrucción 11ª: carga externa de un dato a un lugar de la memoria. Se sustituye los registros en modo desplazamiento por un multiplexor. Y se modifica el código que hay dentro de la interrupción para seleccionar la entrada del multiplexor.

[flip113]

Democrito dejo una foto de cómo hice el ejercicio 7, instrucción 11ª: carga externa de un dato a un lugar de la memoria. Lo hice funcionar sin modificar la programación, pero no me convencía, si me convenció y me aclaro tu solución. Muchas gracias.

[Democrito]

De todas formas Flip, tu circuito tiene buena pinta. No lo he probado pero veo la intención de jugar con los pulsos, eso evitaría tener que modificar el programa.

Lo importante para el futuro es que para cada periferico habrá que adaptarlo al hardware de Atto (añadiendo o quitando cosas) y luego con programación haga lo que esperamos que haga. Sé que no es sencillo hacer dos cosas a la vez, pero esto funcionará así. Y para cualquier duda ya sabes que estoy aquí.

Estoy creando un tutoria sobre PulseView para ver las señales SPI e I2C, porque vamos a dejar los leds para comprobar el funcionamiento y pasaremos a ver las señales desde PulseView, que es lo que realmente nos interesa.

[Democrito]

Todavía no está terminado el tutorial sobre PulseView, pero si alguien lo desconoce y quiere ver los primeros pasos para ponerlo en marcha, dejo enlace:

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/PulseView/readme.md

Cuando crea que está terminado os avisaré.

[Jo mo]

Muchas gracias Democrito and Flip for preparing and playing. 

This Atto tutorial ! This work is very interesting! When i will have Time , i will have a closer look at this little but promising, Atto microprocessor!

Big Hug!

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/4b37e291-5df6-47e9-bdf4-b7238b42dd68n%40googlegroups.com.

[Alfredo Carmona Mirats]

Fabuloso.👍

Falta hacía que se preparara algo sobre el tema, ...es una herramienta estupenda, pero algo complicada de utilizar.

Con el manual que has preparado se superan todas las barreras de comprensión.

Felicitaciones y gracias.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/CAM0%3DoYW-rJggqizk2MhOEXOTUO4pJSrJP8tt3JAPBKhMm2dbgw%40mail.gmail.com.

[charli va]

Felicidades por el manual democrito! Voy a retomar el tema de sigrock porque viene al pelo y así podemos completar tu tutorial con ello. Hoy mismo me priorizo eso.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/CA%2BMbFFZ%3D-jw3Pik2qQ5z0spvPMpjGPk9sJ2CikGvHjrFYpyv1g%40mail.gmail.com.

[Democrito]

Hoy tengo mucho lío personal y en pequeños huecos voy siguiendo con la documentación del tutorial, pero creo que para mañana por la tarde ya lo tendría terminado.

Muchas gracias por los ánimos que me dais, un fuerte abrazo a todos!

[Democrito]

Doy por finalizado el tutorial sobre PulseView: https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/PulseView/readme.md

Ahora seguiremos con las dos últimas instrucciones, que son "AB" y "AF". Aprendermos a enviar paquetes de bytes de cualquier tamaño (máximo 65535 bytes). Cuando tenga documentado "AB" os daré un toque por aquí.

[Democrito]

Instrucción 12:  Envío y recepción de datos serie (SPI e I2C)

https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#ab--env%C3%ADo-y-recepci%C3%B3n-de-datos-serie-spi-e-i2c

[Democrito]

Cuando iba a explicar la última instrucción me di cuenta de algo que lo cambia todo.

Este tutorial será reestructurado en breve. Habrá cambios importantes. Todas las instrucciones explicadas hasta ahora seguirán funcionando igual, excepto AB, que funcionará igual que en I2C en la versión moderna que sacaré pronto. He creado un Atto nuevo, eso significa que sustituiré todos los ejemplos de los tutoriales, y aparte he de explicar cómo se estructura interiormente el nuevo atto. Además, será compatible con otros protocolos, como el rs232. Queda el tutorial en pausa, hasta nuevo aviso. Gracias por la paciencia a los que estén siguiendo este tutorial.

[charli va]

Ni te preocupes Demócrito! faltaría más! está siendo un hilo muy didáctico.e interesante. Ánimo y sigue contándonos los progresos!

El dom, 13 ago 2023 a las 13:10, Democrito (<spo...@gmail.com>) escribió:

Cuando iba a explicar la última instrucción me di cuenta de algo que lo cambia todo.

Este tutorial será reestructurado en breve. Habrá cambios importantes. Todas las instrucciones explicadas hasta ahora seguirán funcionando igual, excepto AB, que funcionará igual que en I2C en la versión moderna que sacaré pronto. He creado un Atto nuevo, eso significa que sustituiré todos los ejemplos de los tutoriales, y aparte he de explicar cómo se estructura interiormente el nuevo atto. Además, será compatible con otros protocolos, como el rs232. Queda el tutorial en pausa, hasta nuevo aviso. Gracias por la paciencia a los que estén siguiendo este tutorial.

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/52350a45-890d-451e-913e-7653217b039fn%40googlegroups.com.

[Democrito]

Las dos últimas instrucciones:

AF: https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#af--leer-la-memoria-y-sacar-una-cantidad-de-datos-por-spi-o-i2c

AB: https://github.com/Democrito/repositorios/blob/master/Micros/Atto64/readme.md#ab--envío-y-recepción-de-datos-serie-spi-e-i2c

Lo esencial ya está. Ahora con más tranquilidad iré añadiendo ejemplos de proyectos y explicaciones hardware.

[charli va]

Fantástico democrito!! Millones de gracias!

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/7a84a1fe-2ada-4b3a-b69e-e9f704e7bd84n%40googlegroups.com.

[Democrito]

Adaptaciones hardware de Atto a los módulos I2C y SPI: https://github.com/Democrito/repositorios/tree/master/Micros/Atto64#configuracion-y-adaptaciones-hardware-de-atto-a-distintos-protocolos

[Democrito]

Doy por finalizado el tutorial.

He añadido los ICEs de Atto para SPI e I2C como módulos: https://github.com/Democrito/repositorios/tree/master/Micros/Atto64/ICEs

También he añadido otro ejemplo de uso de Atto para I2C (el tutorial enlaza a este proyecto) : https://github.com/Democrito/repositorios/tree/master/Sensors/I2C/CCS811

Y también he añadido los reconocimientos.

Iré sumando más proyectos con el tiempo.

Saludos!

[charli va]

Muchas gracias por todo Demócrito, este micro va a ser muy chulo para integrar y hacer muchas cosas y sobre todo muy didáctico, como siempre felicidades por este gran trabajo.

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/a72d2a27-4e78-464a-98d6-6190966b7e58n%40googlegroups.com.

[Democrito]

Documentar Atto, ha sido mi "agosto"!

Un placer, y muchas gracias como siempre Carlos!

[charli va]

Buenas Demócrito! me encanta cuando en la comunidad "vamos sincronizados" y aparecen sinergias.

Ando trabajando como os comenté en un sistema de pipeline de procesos que ayudarán a integrar icestudio con herramientas más complejas , así como establecer flujos con compiladores etc.

Estoy trabajando también en un procesador tipo ATTO, más que en si la arquitectura, qeu es muy diferente, en la idea, un micro muy pequeño que nos permita realizar algoritmos complejos con un conjunto de estos "micro trabajdores", tenemos que buscar un nombre para este tipo de cpus, me pareció super divertido porque andando buscando nombres, empecé por lo típico, "micro", "nano", "femto".... pero ya existían proyectos con todos ellos. 

Buscando conceptos de pequeños "individuos" que realizaran pequeñas taréas pero que en conjunto  fueran muy potentes, encontré a las hormigas "Atta", que no sé si por eso se llama "Atto", desde luego cuando lo enviaste, me sonreí!

Bueno, te cuento esto porque en todo este conjunto de trabajo,  estaba  preparando un primer nivel de abstracción, definiendo un lenguaje ensamblador sencillo muy dedicado a  funcionalidades concretas, luego cuando rodemos un poco todo y saquemos conclusiones con el uso, mi idea es definir un lenguaje tipo C o incluso tipo verilog para intentar simplificar al máximo y que pudieramos trabajar siempre con un lenguaje común, y con el mismo lenguaje pudiéramos volcar a diferentes cpus.

Así que aprovechando tu impulso de Atto, porque mi cpu no estará lista hasta dentro de unos meses ya que tengo priorizadas bastantes cosas de icestudio antes, he estado trabajando en modificarlo para que pueda generar código para ATTO.

Ya está casi listo, esta semana publicaré la primera versión para que podamos jugar con ello :)

Me he adelantado porque ya sólo me queda por implementar los loops y soluconar algunos bugs con la gestión de memoria (bueno luego quedará refinar bien la gestión de errores y posiblemente pulir mucho el parsing) pero realmente para poder empezar a probar, queda muy poco, así quey me gustaría comentarte el lenguaje que he planteado a ver que te parece , por si le ves alguna pega, ves alguna necesidad o se te ocurren mejora con la idea de , modificarlo ya de cara a lanzaros la primera prueba.

Otra cosa que me queda, pero posiblemente de inicio no lo tenga implementado, es poder utilizar diferentes versiones de números (0x para hexadecimal, binario, etc), ahora mimso todo el tema numérico va en decimal

Te cuento como  lo estoy planteando a ver que te parece , un código sin sentido pero para ver todos los nemónicos sería:

; esto es un comentario

; Podremos definir variables en modo byte , entero o vector... para ayudar al compilador la idea es definit tipos de datos predefinidos (enteros de 1 Byte , de 2, strings, matrices de enteros de 16bits...)

_entero_16bits: i2B 23

_entero_8bits:  i1B. 255

_datos_en_memoria:   MAI [10,12,34,46,75,75]

_cadena_de_texto:  MST "Esto es una cadena de texto en memoria"

_dato_guardado: i2B 00

; JAL  etiqueta=> Equivalente a F3
 jal label_A

; Podremos definir etiquetas con texto seguido de : de forma que nos abstraigamos de las direcciones de memoria

label_A:

; TMR unidades sería el equivalente a FB, mi idea es poder poner el número de unidades simplemente y utilizar

; terminaciones tipo 10us. para definir microsegundos o 10ms y ya internamente el compilador hará las conversiones oportunas
tmr 10

; Mandar por el puerto out valor (8B)
out  _entero_16bits

out 255

; Return
ret

; C3 => ldr valor que sería el nemónico   de Load Register
ldr 256

; E3 salto incondicional
jne label_A

; 83 => salto si igual
jeq 10

; Loop, esto lo tengo pendiente de acabar, la idea es utilizar lps  numero_repeticiones (lps = loop start)
lps 32

;contenido del loop

;se introduce el código en este fragmento

; Loop end, simplemente se indica que acaba, ya el compilador calcula direcciones, etc

lpe

; Interrupción

int

; Store memory stm dirección
stm _dato_guardado

; Send data from memory, snd cantidad de datos, dirección de memoria
snd 38, _cadena_de_texto

;Send And Receive  sar bytes_a_recibir, vector de bytes a enviar
sar 5, [1,20,255,10,25] 

Y más o menos eso es todo, me ha venido muy bien tener tu micro funcionando, es muy sencillo , pocas instrucciones y me está viniendo fenomenal para validar esta primera versión del compilador, te lo agradezco mucho, tener varios micros de este tipo nos va a venir genial para probar muchas cosas y veía muy necesario tener un compilador inicial al menos en assembler. Además me está viniendo bien para probar unos parsers y tokenizadores que voy a utilizar en breve en icestudio para importar bloques verilog, así que todo va confluyendo!

En cuanto tengamos la primera versión te haré un pull request a la documentación y demás.

Ya me dices como lo ves.

Un abrazo!

El mar, 22 ago 2023 a las 23:52, Democrito (<spo...@gmail.com>) escribió:

Documentar Atto, ha sido mi "agosto"!

Un placer, y muchas gracias como siempre Carlos!

--

Has recibido este mensaje porque estás suscrito al grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a fpga-wars-explorando-el...@googlegroups.com.

Para ver esta conversación en el sitio web, visita https://groups.google.com/d/msgid/fpga-wars-explorando-el-lado-libre/b61b0fb0-19b8-4bef-9a94-f6477b39866dn%40googlegroups.com.

[Democrito]

Yo lo veo todo fenomenal Carlos y me encanta! Tener un lenguaje simbólico (el ensamblador ya me parece perfecto), es dar un gran salto en facilitar su uso, y no me refiero sólo a Atto, sino a cualquier pequeño micro que en el futuro podamos sacar.

La idea que tengo en la cabeza ahora es que Atto me ha sacado de varios apuros, con el nRF24L01 ni te cuento, que es donde más ha brillado su utilidad. El problema que le encuentro al actual Atto es que es muy difícil de modificar y de comprender qué hace cada parte. Es por eso que quiero hacerlo en verilog, donde se puedan añadir instrucciones y también quitar si alguien quisiese ahorrar recursos, de forma sencilla. Que tenga una lógica intuitiva en este sentido para esa finalidad. Por supuesto, luego podrá ser conectado a otros módulos, para manejar protocolos seriales, cálculos, etc. Aunque mi intención con crear micros, no es que resuelvan cálculos o cualquier otra tarea, eso se lo quiero dejar a módulos externos específicos para ello. En mi cabeza está más bien (como definición o acercamiento de concepto) a una unidad de control, en vez de un micro en su concepto como tal.

Estoy pegagoso con algo que tengo pendiente y de momento me tiene retenido. Pero antes de un mes espero tener un esbozo de micro hecho en verilog y sobre la marcha ir participando todos los que estén interesados/as.

Creo que cuando abramos el nuevo hilo sobre micros, con el tiempo irá tomando su cuerpo y dirección a seguir.

Aprovecho para comentar que Atto tiene una Issue con la interrupción externa. En mis proyectos con Atto nunca he usado la interrupción extrena, sólo en el tutorial, pero al hacer pruebas específicas con la interrupción, y al hacerlo repetidamente llegaba un momento que se colgaba.

Te agradezco mucho el esfuerzo por tu parte de crear un ensamblador que nos ahorre muchos quebraderos de cabeza que tiene la programación en lenguaje máquina. Yo tenía pensado hacer un ensamblador (a mi manera, aunque programo no soy programador) como algo a muy largo plazo, así que me siento muy agradecido.

Un abrazo muy grande!

[Jo mo]

Ola amigos,

About the assembler side, i just found a very interesting free tool  CPUSIM

With it, after configuring our own cpu (called "machine" in CPUSIM software) giving him all the properties  (hardware, intruction set)  we can:

- write our assemby code for our cpu  eg ( here on the right panel it is the program memory)

             

- simulate it  (also in a debug mode)

- and generate an .hex file, or mif file  (File/saveRam/from main)  that we can use in Icestudio (with some cleaning) !

    Indeed, In the following notepad++ view of the file, the interesting columns are in yellow (for that 16bits instructions cpu, one instruction is stored in two line eg: the first instruction bellow is 30 00)

                                or .mif file generated

There are some videos tutorials, but the use CPUSIM seams quite strait forward !

The soft includes  an example of simple created CPU (wombat.cpu)  with a very simple code ( W1-0.a ) that can be simulated. 

Remark all the 2 above picture are the "program ram" generated from  that W1-0.a code

have a nice day guys

[Democrito]

Joaquim looks very good, I'll take a look at him calmly. Thank you so much!