[Oled] [SSD1306] [I2C] un primer acercamiento.

[Democrito]

Hola!

He conseguido poner en marcha una pantalla Oled I2C (SSD1306) de 128x64 píxels. Es sólo un acercamiento a su funcionamiento más elemental. El circuito que he diseñado saca una tabla ASCII un poco diferente a la tradicional que todos conocemos, lo hace como si fuese una imagen completa de ella.

Como podéis comprobar las luces leds y las cámaras no se llevan bien y se ve todo borroso; además de que hay que tener buena vista con la pantalla en vivo.

En realidad se vería esto:

El circuito general me ha quedado así:

Como decía (estoy avisando) el circuito de momento sólo es capaz de sacar una imagen pre-grabada en un fichero (en formato hexadecimal). Todavía no puede escribir texto ni números y menos todavía poner esos caracteres en una zona de la pantalla.

Mientras iba haciendo a la vez iba comprendiendo los pasos que tenía que dar, muchas veces he tenido que dar varios pasos atrás porque iba por mal camino.

Quizás más adelante intento hacer que se pueda manejar como si fuese un LCD de toda la vida, pero electrónicamente hablando es bastante complejo hacer eso.

He de agradecer a un autor (o autores) sus explicaciones de cómo hacer funcionar una pantalla Oled sin librerías. Si le echáis un vistazo sabréis tanto como yo sobre su funcionamiento que podréis aplicar lo aprendido tanto a Arduino como a FPGAs y en castellano. Esta es la web:

https://robologs.net/2018/03/11/como-conectar-una-pantalla-oled-ssd1306-con-arduino-sin-libreria/

Estaré usando imágenes pertenecientes a esa misma web. Por cierto, uso exactamente el mismo tipo de pantalla Oled que la que usan en esa web. Allí lo explica todo con todo lujo de detalles.

Adjunto el proyecto como zip porque además del ICE contiene un archivo de configuración y otro donde está toda la tabla ASCII (como imagen) a representar.

Sería muy largo de explicar cómo funciona el circuito pero voy a hacerlo muy resumido y comentado lo más importante o clave.

En general es importante conocer estas premisas:

Cada vez que quieras llamar a la pantalla Oled lo primero de todo es poner su dirección. La mía tiene como dirección 3C (son 7 bits), falta el bit más bajo (para hacer un byte) que es el de lectura o escritura, y como siempre vamos a escribir, ese bit siempre será 0. Entonces, si 3C es en binario 0111100 (7 bits en total), al añadir el bit más bajo como 0, nos queda: 01111000, es decir, 78 en hexadecimal. Si fuésemos a lee (pero este no es el caso) entonces la dirección sería 79, ya que el bit más bajo valdría 1 (para poder leer).

Después de enviar el byte de dirección viene un byte de comando. Sólo vamos a necesitar conocer dos comandos el 00 y el 40.

* 00 Lo enviamos para decirle a la pantalla Oled que todo los bytes que reciba después de éste son comandos de configuración de la pantalla Oled.

* 40 Lo enviamos para decirle a la pantalla Oled que todo los bytes que reciba después son para escribir en la pantalla. Lo hará en forma de píxels en grupos de 8 y en vertical. En esta imagen se ve perfectamente la idea:

Se comprende que después de enviar 78 y 40 los siguientes bytes se imprimen como 8 píxels verticales. Cada vez que reciba la pantalla Oled un nuevo byte se pasa a la siguiente columna de píxels automáticamente. Como esta pantalla es de 128x64 píxels, cuando llegue a la columna 127 (comienza en 0) y quiera pasar a la siguiente, volverá al comienzo y 8 píxels más abajo. Todo esto lo hace automáticamente, es su forma de funcionar con la configuración que le metí.

Ahora bien, ¿cómo sabe la pantalla Oled cuándo comienza o termina una ristra de datos, ya sea para configurar o para pixelar? La respuesta está en el protocolo I2C. Cuando vamos a enviar datos de comandos o píxels, antes hay una señal de "start" y cuando termina de enviar datos hay una señal de "stop".

Los dos ficheros de extensión ".list" son los datos que irán almacenados en dos memorias (las estoy usando como si fuesen ROM, aunque se puede escribir sobre ellas). Una de las memorias es de 32 bytes, y la otra es de 2 Kbytes.

Por el tipo de diseño que he hecho gestiono la memoria de una forma un poco particular. Uso dos bytes (que nada tiene que ver con la pantalla Oled, sino que son necesidades del circuito) para saber cuánta información voy a enviar, de esta manera sé cuándo he de enviar la señal de "start" y "stop" del I2C. Y después viene el volumen de datos real para la pantalla Oled. Si abres cualquier de los dos ficheros con un editor de texto, verás las explicaciones de qué es cada cosa. En "font.list" tuve que trocear el envío de información en bloques de 100 bytes aproximadamente (cantidad arbitraria, es decir, tomaba 100 por comodidad para mí) porque de otra manera (todo de un golpe) me daba error.

Saludos.

[Juan Gonzalez Gomez]

¡Muchísimas gracias Demócrito! :-)

Hace tiempo me compré una OLED para ponerla también en marcha, así que partiré de lo que estás haciendo.  He estado viendo tus circuitos y .... ¡Me encantan! Son muy intuitivos y fáciles de seguir!

Yo ahora estoy trabajando en la consola serie pero tengo la idea en la cabeza de ir unificando poco a poco todos los dipositivos de entrada/salida para que sea muy fácil usar unos u otros. Tanto el LCD como la OLED serán dos candidatos a meter como salida estándar (stdout)

Es una aportación buenísima. Muchísimas gracias, de verdad 😊

Saludos, Obijuan

--
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/1e295fb5-5f08-4f01-8d91-9be45c532975%40googlegroups.com.

[charli va]

Demócrito eres un crack!!! que gran aportación de verdad! hacer fácil el manejo de todos estos displays harán que seamucho más fácil que las FPGAS se difundan, de verdad muchas gracias!.

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

[Democrito]

Muchísimas gracias a vosotros por la labor que estáis haciendo y que todos nos nutrimos!

[Democrito]

Acabo de corregir un glitch que tenía en la versión que subí en el post anterior. Me aparecían unos puntitos (justo al comienzo) que no debían estar pese a que todo lo demás salía bien. He aumentado un bus que tiene el controlador I2C de 12 a 16 bits que sirve para contar la cantidad de bits total que ha de enviar entre el start y el stop y eso ha resuelto el problema. Ahora puedo enviar 1024 bytes de un golpe sin tener que trocear la información.

Estos días voy a hacer el intento de poder escribir lo que queramos en ella.

Adjunto zip con todo corregido.

Saludos.

[Democrito]

Sólo una pequeña tontería, mostrar el logotipo de nuestro grupo de FPGAwars.

Siempre me compro el móvil más barato que veo (no porque no pueda comprar uno mejor) porque para lo que lo uso no me gasto más de 100 euros, llamar y algún whatsapp (bueno, y una calculadora científica sin anuncios llamada "realcalc"). Por eso la imagen es tan mala, por el móvil, pero en vivo se ve perfecto.

Adjunto zip, aunque lo único que varía es el fichero "font.list" (una imagen de 128x64 pixels B/N en hexadecimal) con la añadidura de la cantidad de bytes que ha de enviar[402 en hexadecimal, es decir, 1026 en decimal] que son la dirección [78] y comando [40] + 1024 bytes de imagen y termina en FFFF para que el circuito sepa que puede descansar...).

Saludos.

[charli va]

Hola democrito! Estos días están siendo complicados para mi pero mañana voy a intentar probar tus circuitos, creo que tengo la misma oled por aquí.

Mil gracias esto va cogiendo forma!

--

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/bbe532b3-78be-460e-af36-b03ef4a7e00b%40googlegroups.com.

[Obijuan]

Madre mía!! Eso tiene una pinta estupenda!!! Muchísimas gracias! :-)

Yo también tengo una OLED por aquí. En cuanto pueda lo pruebo. Esa pantalla es ya otro nivel! :-)

Saludos, Obijuan

[Diego Harosteguy]

Genial Democrito!, que bueno los avances!, yo tambien tengo ganas de probar los circuitos!.

Saludos.  Diego.

[flip ma]

Democrito que bueno, eres un maquina, lo he probado y funciona

El domingo, 15 de diciembre de 2019, 22:55:52 (UTC+1), Democrito escribió:

[Democrito]

Hey! Diego & "flip ma"

Muchas gracias por los comentarios y pruebas!

Un abrazo!

[Diego Harosteguy]

Que bueno democrito!, me encanta, aca la captura de la oled funcionando!!.

Gracias!.

                 Saludos. DIego

[Democrito]

Mola!

Y en agradecimiento por vuestras pruebas os adjunto vuestros nombre/nick personalizado. Sólo hay que darle a upload y eso es todo.

Muchas gracias por las pruebas!

[flip ma]

que bueno, muchas gracias

El domingo, 15 de diciembre de 2019, 22:55:52 (UTC+1), Democrito escribió:

[Democrito]

Voy a explicar cómo hacerlo. No es moco de pavo (no es sencillo) porque son muchos pasos.

En Windows abrís el Paint que viene por defecto.

Le das a cambiar tamaño:

Luego desvalidas la casilla "Mantener relación de aspecto" (aquí se me olvidó enmarcarlo en rojo) y elegís "píxeles" y ponéis 128 y 64.

Escribir y/o dibuja lo que quieras dentro de ese recuadro en blanco y lo guardas como"Mapa de bits monocromático"  (es decir, en blanco y negro puro) y le pones la extensión ".bmp".

Te vas a esta web y te descargas este programa: (yo le doy a "LCD Assistant.zip")

http://en.radzio.dxp.pl/bitmap_converter/

Lo ejecutas.

File ----> Load y cargas el BMP que has dibujado antes.

Lo dejas todo tal como está, sólo cambia lo que pone: "Width" y "Height" y pones 128x64 (lo mismo que mide en píxeles nuestra oled).

Y para terminar, salvas el archivo como txt, en mi caso ahora es "ejemplo.txt".

Ahora necesitamos un editor de texto que es genial llamado "notepad++"

Abrimos el fichero txt con él, o bien abres notepad++ y luego lo cargas.

Te saldrá algo así:

Has de copiar sólo lo que pone la parte hexadecimal, nada más, que he puesto en gris (en realidad es seleccionar texto, para ser copiado), sin llaves, sin nada más.

Copias eso, borras todo (no ha de quedar nada) y pegas. Ahora sólo quedará lo que copiaste es decir, los números hexadecimales con sus comas y espacios, nada más.

Le das a "control F" (de buscar) y vamos a eliminar lo que no nos interesa, sólo queremos los valores, pero sin el 0x, ni las comas y ni espacios, pero han de estar "sangrados" con un "nueva línera" (\n). Tranqui, vamos por pasos.

Al pulsar "control F" verás una opción que pone reemplazar. La eliges.

Y lo dejas todo tal como ves en la imagen. "Reemplazar" y lo demás.

Ahora vamos a eliminar todo lo que no nos interesa. El "0x" no nos interesa, pues ponemos que busque "0x" y que lo reemplace por nada, ni siquiera espacio, es por nada.

Y le das a "Reemplazar todo"

Vamos a eliminar ahora la coma y un espacio y lo sustituimos por "\n". Y le damos a "Reemplazar todo".

Y ahora buscamos "," (sólo coma, sin espacios) y reemplazamos por nada. Le damos a "Reemplazar todo".

Ya casi lo tenemos. Este programa pone el número de línea, si el último número hexadecimal es el 1024 es que todo está bien.

Nos falta muy poco, hay que añadir a mano 4 números hexadecimales al comienzo (04 02 78 y 40) y dos al final (FF y FF).

Y ya para terminar con todo esto, hemos de guardar este fichero como "algo.list", donde "algo" es el nombre que tu quieras, pero es importante la extensión, siempre ha de ser ".list". Y lo guardas.

Ahora abres el fichero que os he enviado en el post anterior (tiene la particularidad de que puedes cambiar el fichero) y pones en "Nombre" el nombre del fichero que hayas guardado antes y que termina en ".list", recuerda que ha de estar en el mismo lugar o carpeta que el ICE.

Lo subes y ale!

El dibujo original es un poco diferente al del comienzo porque metí la pata en la edición y lo tuve que rehacer.

Saludos!

[Diego Harosteguy]

Excelente!! gracias!, me encantó

[Obijuan]

¡¡Qué bueno!!!!!!  :-)

¡Grande Demócrito!!

Flip map, me encando esta foto!! 😍😍😍

Saludos, Obijuan

[charli va]

Que gran explicación! gracias Demócrito!!! y vaya entorno de trabajo flip ma!

--
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/8eb1f5c8-fa43-4e68-ba9f-2c152610733b%40googlegroups.com.

[flip ma]

El domingo, 15 de diciembre de 2019, 22:55:52 (UTC+1), Democrito escribió:

[charli va]

Jajaja sois unas maquinas!

Gracias a vosotros!!

--
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/2aa491cc-797e-4747-a2dd-1388c3238809%40googlegroups.com.

[Democrito]

Jajajaja! qué pasada! dos pantallas!

Muchas gracias flip ma!

[Democrito]

Estamos en fechas navideñas y como los niños/as son quienes más las disfrutan de verdad se me ha ocurrido buscar algunos dibujos y meterlos en la Oled.

El pato Donal.

Una vaquita, que no se ve muy bien... pero en vivo se ve perfecto.

Los dibujos originales los saqué de unos archivos que conservo con extensión .PLT (HPGL) de la época que me hice un plotter (muchos años antes de las impresoras 3D) y que luego usé tb en unos simuladores de brazo robot porque son muy fácil de interpretar. Pues estos dibujos (PLTs) son literalmente líneas y si se indaga dentro ves algunos códigos como "pu" (pen up) o "pd" (pen down) o "pa" (absolute position) y números que son coordenadas x,y.

Me fui a esta web: https://sharecad.org/es

Subí el archivo PLT que me interesaba y te lo saca en la pantalla. Luego hay opciones para regruesar las líneas o no, tocando el ratón puedes mover y hacer zoom, etc. Total, que hice un "copiar pantalla" a varios PLTs y os muestro cómo sería originalmente.

Como es 128x64 para que algo se pueda ver bien se necesita que sean cosas muy concretas, entonces copie sólo un trozo con el paint del Windows (y luego lo que ya puse en un post anterior para pasarlo a hexadecimal). Por ejemplo, la nave espacial (creo que es el Discovery) no es posible sacarlo con esa resolución, a no ser que siempre fuese con mucho zoom y verlo a trozos.

Adjunto el experimento. He puesto los dos ejemplos de las fotos de antes: donal.list y bull.list. Como curiosidad, en otra carpeta he dejado varios PLTs.

Saludos!

[Democrito]

He estado jugando un rato, mirando cómo se hace scroll. No sé cómo se hace realmente pero he cogido el datasheet y he estado probando comandos que vienen ahí de ejemplo.

Dejo vídeo: https://www.youtube.com/watch?v=x3PCc5_8k1g

Adjunto los cambios; sólo he añadido al final de los dos ".list" que puse en el anterior post esos comandos de scroll. Si abres esos archivos podrás verlo, están comentados para evitar confusión con el resto de la memoria. Podéis poner cualquier imagen y añadiendo esos comandos de scroll y se moverán de la misma manera que en el vídeo.

Saludos.

[Democrito]

Hola de nuevo,

He estado tratando de enviar comandos y dibujos a través del puerto serie. Los drivers (demo) de Oled que he estado subiendo hasta ahora no permiten hacerlo y salen cosas extrañas (viendo las señales desde PulseView). Interiormente tiene una construcción en la que funciona a piñon fijo, así que necesita tener la información disponible a la velocidad de I2C. Al final he conseguido que pueda funcionar a muy baja velocidad de transferencias de datos.

Esa separación entre los paquetes de datos antes eran imposible, tenían que estar todos pegaditos a la fuerza.

Como comentaba, ahora ya se puede hacer y he probado velocidades de 9600 baudios. El circuito es exteriormente muy sencillo; e interiormente (paradógicamente) he eliminado algunos elementos y re-cableados otros.

Tan sencillo como parece. No se necesita las señales "next" ni "end" porque el I2C/Oled es en comparación mucho más rápido, es decir, que para cuando se produce un tic en la patilla "next" ya hace rato que está esperando una validación por "innext" con el nuevo dato.

Esta parte era crucial porque ahora sigue una lógica de funcionamiento como realmente se espera; que funciona con memorias y con paquetes de datos espaciados en el tiempo.

Doy por hecho que este tema, hasta el momento, ya estaréis saturados porque no traigo nada nuevo que "ver", pero si alguien quiere hacer pruebas dejo instrucciones.

1.) Te descargas el zip que viene en este post, y un programa externo que pongo aquí (para Windows). El programa .exe hay que ponerlo junto a los archivos .list. Ese programa lo único que hace es enviar byte a byte el fichero .list que hayas escogido (de dos que hay) y lo envía a la FPGA.

2.) Arrastras cualquiera de .list hacia el ejecutable (.exe), te preguntará por el número de puerto COM que tengas conectada tu FPGA, se lo das, y lo envía. El programa es muy parecido a la versión anterior que hice para subir programas al Z80_FPGA.

Los .list de este post son incompatibles con versiones anteriores, sólo sirve para el ejemplo que adjunto en este post, porque para enviar por el puerto serie no puede llevar espacios, ni comentarios, etc, así que va todo sobre una misma línea. Dentro ya lleva la configuración y el dibujo que se quiera mostrar. A la configuración le he añadido un comando que es deshabilitar scroll, porque si se quiere mostrar una imagen fija habiendo cargado anteriormente una con scroll, se pondría a hacerlo, es decir, que sólo hará scroll cuando realmente lo tiene que hacer.

Para mí esto es un avance, porque ahora puedo hacer depuraciones y pruebas más directas. El objetivo es que sea tan fácil de manejar como con un Arduino (poder escribir lo que queramos y todo eso).

Saludos.

[charli va]

Hola Demócrito! mucho ánimo y sigue dándole caña! que si a ti te motiva y te interesa el tema, toda la información que envíes nunca será de más ni aburrida ni pesada.

Al revés agradecerte muchísimo que compartas lo que estás haciendo.

Yo aún no he sacado tiempo par probarlo, andamos ahora estabilizando la rama develop de icestudio y con la tarjeta sd que ando al límite de tiempo, pero en cuanto pueda lo probaré e intentaré ver como integrarlo con icecrystal , mi idea con icecrystal es reunir ahí todo tipo de displays y patrones de diseño así como bloques que permitan hacer cosas comunes (animaciones, posicionar , cosas, etc) así que todo lo que avances te aseguro que será super bienvenido (y como si te animas tú a integrarlo ahora o más adelante :)  ),  así que lo dicho no desistas nunca!

Un abrazo!

--
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/5f497be4-f779-4ed1-8500-580710ad224a%40googlegroups.com.

[Democrito]

Charli! Muchas gracias por tu aliento! Siempre estás ahí animando y currando a tope y se agradece mucho. 

[flip ma]

Hola charliva lo he probado tal como lo explicas y funciona, un saludo.

[flip ma]

Perdón! Perdón! Perdón! Hola Democrito el comentario anterior era para ti perdona por confundirme en el nombre, se me fue la cabeza. 

[Democrito]

flip ma, se agradece mucho las pruebas, tanto si va como si no. Si no te funcionase y a mí sí, puede significar (por ejemplo) que existan inconsistencias dentro de Icestudio. Yo modifico muchas cosas que ha diseñado Obijuan (me refiero a las bibliotecas) para adaptarlo a mis necesidades y las pongo como clones para no modificar el elemento original. Por eso es importante las pruebas, porque si a un usuario le funciona y a otro no, hay que buscar qué es lo que está pasando.

Las pruebas son más importantes de lo que pensamos para ver esos detalles. Por eso se agradece mucho.

Muchas gracias por estar ahí, flip ma.

Un abrazo!

[Juan Gonzalez Gomez]

Woala!!!! no había visto esta foto!!!! jajaajajajajj  ¡Gracias flip ma!

--
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/2aa491cc-797e-4747-a2dd-1388c3238809%40googlegroups.com.

[Juan Gonzalez Gomez]

Woala!!! Cómo mola el scroll!!!!   😃😃😃

--

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/435a3d34-998a-4222-9a75-5254fbe8bc6a%40googlegroups.com.

[Obijuan]

¡Esto es un super avance! Muchísimas gracias demócrito! :-)

[Obijuan]

Acabo de pedir 2 pantallas oled SSD 1306 por I2C 128x64, para probar los circuitos de Demócrito :-)

Tengo por aquí el modelo SH1106 que va por el SPI, pero antes de adaptarlo prefiero hacer las pruebas con lo que ya sabemos que funciona

Os iré contando

¡Gracias Demócrito!  :-)

Saludos, Obijuan

[Democrito]

Genial!

Yo sigo trabajando para que se pueda escribir. Pero no voy directo, sino que por el camino me encuentro cosas y he podido mejorarlo más y simplificar otro poco más. Estoy ahora con el CLS (borrar pantalla) que va a ser esencial y para no gastar memoria lo estoy haciendo electrónicamente.

Como tú dices muchas veces, "esto es súper adictivo!" y vas comprendiendo cómo funciona realmente todo.

Saludos!

[Obijuan]

Me acaba de llegar la pantalla OLED I2C.... y ......

¡¡¡FUNCIONA!!!!!  :-)

No he tenido que tocar nada ni configurar nada. Sólo conectarla, cargar el circuito de Demócrito y ya está!  :-)

Esto me ha disparado el SAV!!!!

¡¡Gracias demócrito!!!

(Demócrito: tienes usuario en twitter?)

Saludos, Obijuan

[Democrito]

Hola Obijuan! Me ha encantado verlo!

Cada vez que subí un zip con el proyecto, cada uno de ellos tenía una mejora añadida. Adjunto lo último que tengo hecho hasta ahora con cosas importantes corregidas que no eran evidentes en versiones anteriores. Ahora lleva incluido un CLS y se puede encadenar "acciones"; de momento sólo necesito 4 (configuración inicial, CLS, Memoria de la imagen y posibilidad de comandos externos).

Al cargarse el circuito verás que no sale nada (sólo puntos aleatorios, o bien la última imagen que la retiene por unos minutos). Si le das al pulsador SW1 te aparecerá el pato donal, y si das otro y lo mantienes se borrará la pantalla, utilicé tu cribador de clics. Y puedes repetir tantas veces como quieras, los clics y los clics sostenidos.

No tengo cuenta twitter porque no uso redes sociales.

Saludos!

[Democrito]

Se me olvidó poner en el zip el archivo de configuración inicial. Vuelvo a re-subir el archivo con todo correcto.

Borrar todo lo anterior y descomprimir este.

[Obijuan]

Probado!  :-)

¡Gracias Demócrito!

Ya lo tengo funcionando. Con long click se borra la pantalla y con un click aparece Donald

Este ejemplo me ha venido fenomenal porque al probarlo con icestudio devel (de la rama develop) se produce este error:

ERROR: timing analysis failed due to presence of combinatorial loops, incomplete specification of timing ports, etc.

Icestudio develop utiliza la nueva toolchain next-pnr que es mucho más potente. En este caso ha detectado que hay un bucle combinacional en alguna parte (es algo que se debe evitar al hacer diseños digitales) 

No he podido ver todavía dónde está ese bucle

Con icestudio 0.5.1 se sintetiza y funciona sin problemas

He visto que nextpnr tiene el flag --ignore-loops, que justamente ignora esos errores y permite el sintetizado. Tengo que ver cómo integrarlo en la toolchain (apio primero y luego icestudio)

Saludos, Obijuan

[Democrito]

He probado a subir (con Icestudio develop) cualquier cosa y no sé por qué ahora no deja, no importa lo sencillo que sea el circuito. Y estoy utilizando el mismo git que la anterior vez.

Me sale esto: (estoy bajo Windows)

[Democrito]

Vale, parece ser que el error se debía al antivirus Avast. Lo he desactivado y vuelto a comenzar desde el principio, es decir, npm install y luego npm start, reinstalar la toolchain, tomar un circuito complejo y subirlo. Dejo un pantallazo.

[flip ma]

Genial Democrito, trasteando un poco le coloque un bloque que nos da un tic para poder ver la imagen en el arranque

[flip ma]

Pongo la foto, un saludo

[Democrito]

Esa es una de las soluciones flip ma!

Lo subí así porque así lo tenía a propósito para mí, en el sentido de que no era el circuito a presentar de manera oficial. Sólo era ver que existe una forma de hacer CLS (borrar pantalla).

Verás que todos los módulos de la izquierda (Config, BITMAP, CLS y falta otro módulo que es de comandos externos) tienen una patilla llamada "busy" que se pone a 1 y se mantiene a 1 mientras está activo esa función/módulo. Están pensados para ser encadenados, entonces, cuando "busy"  baja, es decir, se pone en flanco de bajada (aquí habría que añadir ese módulo que está en la biblioteca) podría activar el siguiente módulo y encadenarlos en esta secuencia:

Inicio y configuración (que es un módulo) -----> CLS ----> presentar imagen (BITMAP).

Y aquí puede haber mucho juego de posibilidades, por ejemplo, mantener apagada la pantalla (que no muestre nada, existe un comando para eso) hasta que el termine de imprimir los datos en pantalla (es decir, que al final se le da el comando de mostrar lo que esté en la memoria de la Oled), así tendríamos un encendido completamente "limpio".

El CLS que le he implementado es sólo para la Oled, no es un CLS de los píxeles que vamos a representar (memoria interna de la FPGA). Digamos que la Oled también tiene una memoria y ese CLS va a esa memoria, poniéndola todo a 0 y es lo que presenta cuando activamos ese módulo.

La cuestión es que has dado con una solución y eso es lo importante!

Saludos!

[flip ma]

Muchas gracias por la explicación Democrito, eres un artista.

[Democrito]

Espero que los Reyes Magos os hayan traído muy buenos regalos!

He conseguido hacer un poco de edición con la Oled. Se trata de tomar un terminal serie (el de Arduino, Script communicator o cualquier otro) y representar en la Oled todo lo que se escribe.

Inicialmente la pantalla se mantiene negra, no se ve nada. Al escribir un texto y darle al "enter" muestra lo que hayas escrito. Si se enviase carácter a carácter también lo presentaría.

Reconoce el "retorno de carro" (chr 13) y "nueva línea" (chr 10), pero sólo hay que usar uno de los dos, porque si usas ambos (esto es muy común en Windows) saldría doble sangrado y sólo nos interesa uno. Esto hay que tenerlo presente por ejemplo con el terminal de Arduino si usas ese.

Normalmente usamos una velocidad en baudios de 115200, sin embargo no podremos usar esa frecuencia. En un anterior post puse un ICE que enviaba una imagen prácticamente a cualquier velocidad, pero ahora es distinto, es otra naturaleza de funcionamiento (un circuito mucho más complejo). En ese otro circuito se trataba de enviar byte a byte una imagen y no hay problema, pero ahora hemos de convertir un código ASCII (un byte) a 8 píxeles horizontales, es decir, que en un mismo tiempo ha de trabajar 8 veces más.

El circuito está por defecto configurado a 9600 baudios (es la velocidad más estandar que existe) y a partir de 57600 es seguro que falla (salen cosas raras o dos letras que nada tiene que ver). La cuestión es que si alguien prueba el ICE que adjunto este post no se le olvide re-configurar dicha frecuencia a 9600. Y si por lo que sea quieres probar esta parte, recuerda cambiar dicha velocidad tanto en el ICE como en el terminal serie.

Es un circuito muy complejo que realiza acciones muy sencillas y que deja mucho que desear. No hemos de olvidad que una cosa es programar y la otra es diseñar una electrónica que haga eso mismo.

Este diseño que adjunto es sólo para probar que funciona y tiene un tipo de edición mínima, una simple demo.

Ahora voy a comentar cosas que os van a suceder si lo probáis.

• Admite 16 caracteres alfanuméricos por línea, si te pasas de 16 se escribirán en la siguiente línea, pero el retorno de carro (o nueva línea) no lo respetará. Esto quiere decir que cuando haya un retorno de carro (o nueva línea) lo siguiente que venga se imprimirá encima de lo que haya sobrado abajo.

• El máximo de líneas es de 8. Si se trata de crear más líneas lo hará al comienzo (arriba a la izquierda, volviendo al principio) y chafará lo que halla allí.

• Como esto es un simple editor, creí conveniente crear un comando que significase "borrar pantalla". Para ello he utilizado la letra "¡" para esa acción. Miré algo que tuviéramos en el teclado que no le afectasen las mayúsculas y minúsculas y como es poco usado (o nos entendemos igualmente sin ese carácter) usé el comienzo de "admiración" (¡) que usamos en castellano para usarlo como CLS. Mientras se hace pruebas este comando es muy útil, pruébalo!.
• Para evitar problemas, trata de escribir como si estuvieras en un teclado inglés [de momento nada de eñes (ñÑ), ni 'C' cedilla (çÇ) ].

• Por cierto, el ASCII que utilizo es el mismo que en el primer post con el que abrí este hilo. No quiero saturar ahora con información extraña, pero lo que hago es tomar el carácter ASCII que viene del puerto serie, lo multiplico por 8, y me da el lugar exacto donde comienza los píxeles de ese carácter (lo mismo que un puntero en C, por ejemplo), y un contador lee 8 bytes (todos juntos es la letra, número o símbolo) y lo representa.

• He modificado muchas cosas para que fuesen más eficientes (y eran por obligación necesaria) y ello significa que cualquier "ICE" o "list" no es compatible con este nuevo proyecto. Aún así, he comentado todo lo que me ha dado tiempo hasta el momento. 

El circuito es tan sencillo como lo ves. Eliges dos patillas para el SDA y SCL y eso es todo, en mi caso son las patillas D0 y D1 respectivamente. Pese a que la pantalla es I2C no necesita resistencias pull-up, porque como es de sólo escritura no las necesita (no he usado ningún tri-estado en este proyecto).

Para quien esté leyendo esto: Esto es sólo una demo, modificar el circuito para uso propio es algo bastante complejo. Estoy intentando ver la manera de que cualquier cosa que se quiera modificar se pueda hacer de la manera más fácil y me llevará un tiempo.

Lo importante ahora mismo es haber llegado hasta aquí. Voy a buscar la manera de que hagamos un diseño, por ejemplo, leer un ADC o un sensor de temperatura y humedad y que lo muestre en la Oled, y sea sencillo comprender cómo hacerlo. Mi cabeza da muchas vueltas en este sentido y espero conseguirlo.

Me ha sido imposible grabar un vídeo de demostración, las letras son de 8x8 y me aparecen en exceso borrosas.

Adjunto ICE.

Saludos!

[Democrito]

Hola,

Estoy experimentando la edición de salida de datos para la Oled e iré sacando demostraciones de ello.

Esta demo es un simple contador que cuenta de 0 hasta 999. Como puede representar 4 caracteres ASCII me sobraba un dígito y lo he aprovechado para poner un punto decimal. Así que para el que lo pruebe verá contar desde 00.0 hasta 99.9.

Los dígitos se pueden poner en cualquier parte de la pantalla, lo he centrado tal como ves en el esquema. Situar en el eje X funciona por píxeles, así que se puede elegir desde 0 hasta 127. Pero el eje Y funciona de otra manera; como son 8 píxeles verticales y en ese eje hay 64 píxeles en total, la opción es de 0 hasta 7 (64/8=8 posiciones, es decir, desde la posición 0 hasta la 7).

Quien lo quiera probar puede jugar con eso, o quitar el punto, o ponerlo entre otros dígitos, etc. Por otra parte tiene una pausa de 50ms, si eliminas esa parte y haces conexión directa contará 999 en unos 2 segundos.

Adjunto ICE.

Saludos!

[flip ma]

Democrito lo veo y no lo creo, estoy impaciente por estudiar detenidamente el proyecto.

Te pongo una foto en pleno conteo, le cambie la situación.

Muy buen trabajo, muchas gracias y un saludo.

[Democrito]

Jolines Flip ma, muchas gracias por probarlo!

Yo creo que no es importante entender el circuito (en el sentido de que seguramente hay miles de formas de hacer una cosa de formas muy diversas), sino que si conoces el comportamiento de uno, ser capaz de adaptarlo a algo que necesites porque al final es de lo que se trata, ya sea con un Arduino o con un diseño para nuestra FPGA. Por ejemplo, Obijuan nos ha regalado una impresionante biblioteca que son los ladrillos para construir cualquier circuito de forma sencilla. Yo por ejemplo no sé todavía cómo funciona la máquina de contar (cuando miro dentro veo e intuyo, pero realmente no sé cómo trabaja), sin embargo la uso porque sé qué es lo que hace.

Para situar algo en la pantalla lo importante es recordar aquello que estudiamos en geometría, con dos puntos puedes hacer un rectángulo, se entiende que cada punto tiene un eje X y otro Y (dos grados de libertad).

El comando es ese en azul oscuro, y electrónicamente uso registros de desplazamiento (en paralelo de 8 bits) y configurables en cualquier momento. Donde dejo fijo la dirección '78'; luego viene avisar la acción a ejercer: configuración o escritura en pantalla, en este caso es configuración con el comando '00'; y luego en viene un '21' que es configurar X min y X max, y lo mismo para el eje Y (el 22 y los otros dos bytes).

El x0 e y0 lo dejo para ser modificado por el usuario.

El x1 e y1 los tengo puestos al máximo (es decir, hasta la esquina inferior derecha de la Oled).

Este comando tiene la peculiariedad de que encierra el universo dentro de esas coordenadas (x0, y0), (x1, y1), es decir, que nada podrá salir de ahí si así lo has configurado, incluso un CLS (borrar pantalla) sólo lo hará dentro de esa zona si así lo has configurado. (No hay ningún problema en hacer que el CLS sea a pantalla completa, pero si la última configuración que tenía era una zona más pequeña, para hacer un CLS a pantalla completa hay que volver a reconfigurar los puntos (x0,y0), (x1,y1)). En Basic existe un comando que funciona muy parecido llamado "View".

Cualquier duda o lo que sea aquí me tienes.

Saludos!

[Democrito]

Un pequeño detalle. La máquina de contar (en el circuito principal) está limitada a 10 bits, por tanto puede contar hasta 1023 (desde 0 hasta 1023 en binario). Pero el conversor BCD sólo puede contar hasta 999.

Es una máquina de contar modificada, de hecho todas las máquinas de contar en este proyecto están modificadas (había partes que comprendía y experimenté modificaciones antes de volverlas definitivas y por necesidades de diseño son así), y no dependen del número máximo. Pero eso es otra historia.

Si observáis detenidamente el conteo la primera vez lo hará bien, pero a partir de la segunda vuelta no. La razón fue inercia, se me olvidó poner una máquina de contar con límite máximo para acotarlo a 999.

Es por eso, que a partir de la segunda vuelta, al contar 02.3 después se pone a 00.0 otra vez y luego cuenta bien. Por no estar acotada, esos 24 pulsos (de 0 a 23) de más se repiten a partir del segundo ciclo de conteo.

[charli va]

Hola Demócrito! tenía pendiente probar tu circuito! 

Te mando el vídeo del contador, comentarte que funciona perfecto con la nueva toolchain y ha funcionado a la primera ¡enhorabuena!!!!

Tengo ganas de ponerme con ello y sugerirte cosas, los temas gráficos me apasionan, sigue dándole duro que esto tiene un pintonazo!

¡Un abrazo y como siempre gracias por compartir!

--

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/75bd34af-c313-4490-a158-fd6d2d4ed680%40googlegroups.com.

[Democrito]

Muchas gracias Charli!

Ahora estoy ideando la forma de hacer los caracteres el doble de grandes y de una manera eficiente (casi igual de rápido que con los 8x8 que hemos visto hasta ahora); al menos en mi cabeza es así, ahora hay que ponerse con la realidad electrónica. Por otra parte me estoy mirando el temita CORDIC y no me ha parecido algo excesivamente complejo (aunque todavía me tengo que documentar más). Si hubiese una forma de hacer cálculos las posibilidades de hacer proyectos se dispararían exponencialmente. Si logro hacer los caracteres más grandes, aparcaré un tiempo el tema Oled para ponerme a ver cómo clavar los dientes al CORDIC,

Un abrazo muy fuerte Charli y muchísimas gracias por las mejoras que estás haciendo con Icestudio! (es un gozada!)

[charli va]

Genial Demócrito! seguiremos de cerca tus avances!

--

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/8233545c-490d-4e13-97de-03b7d02eaad9%40googlegroups.com.

[Obijuan]

¡¡¡Brutal Demcrito!!

Muchisísimas gracias!  Lo acabo de probar ahora mismo... y va genial!!!

Desde el terminal escribo a 9600 baudios y se muestra en el LCD. El salto de línea funciona también con el Enter, y el comando de borrado de la pantalla.

Esto es un gran avance!!! :-)

Saludos, Obijuan

[Obijuan]

Cronómetro probado!

Va de lujo!!!!!! uuuuuueeeeeeee

Muchísimas gracias! :-)

Saludos, obijuan

[Democrito]

Jajaja! Muchas gracias Obijuan!

[Democrito]

Hola,

Os traigo el mismo proyecto anterior, un contador, pero esta vez los caracteres son de 16x8 píxeles, es decir, mismo ancho pero el doble de largo. ¿Por qué no más grandes? Por que resulta que la mayoría de fuentes existentes tienen una forma de representarse que es incompatible al simple método que yo manejo. Y pensé en crear mis propias fuentes e hice algún intento, pero era un trabajo muy elaborado y que absorbía muchísimo tiempo (imagina crear píxel a píxel 127 caracteres...). Por suerte encontré un tipo de fuente compatible con el modo de trabajo que tenía pensado y es la que uso en este proyecto.

Esta vez he tenido presente el contaje máximo BCD y la máquina de contar está limitada para contar bien desde el 0 hasta el 999, aunque le pongo un punto decimal para quedar menos soso. Podéis copiar esa máquina de contar y sustituirla en el proyecto anterior para que cuente bien.

La forma de funcionar es muy sencilla. Antes pixelábamos con 8 bytes para cada carácter, y ahora hacemos lo mismo, pero en dos veces, porque es el doble de alto. Evidentemente cada carácter (en vez de ocupar 8 bytes) ahora ocupa 16 bytes.

Para conseguir esto se necesita leer la memoria dos veces, en la primera pasada lee los 8 bytes más altos que corresponde a ese carácter, y en el segundo barrido lee los otros 8 que faltaban y completa el carácter a representar. Esta es la manera más simple y sencilla que se me ocurrió. Se trata de jugar con la memoria.

Otro detalle importante es lo que comenté en un post anterior sobre crear una zona acotada de impresión. Si limitas la zona de impresión, escribir se hace más simple. Veamos una imagen de ejemplo.

Como siempre voy a escribir 4 caráteres sé que el ancho es de 8 bytes por 4 (por cada carácter) ocupa un espacio en el eje x de 32 bytes (y píxeles en anchura). Cuando leo la memoria tengo en cuenta todo esto para hacerlo coincidir con lo que quiero representar.

Además permite situar esos 4 caráteres (en este proyecto son números) en cualquier lugar de la pantalla. Esta vez tuve que hacer una cosa para que todo encajase. Interiormente hay un circuito que se encarga de situar lo que queramos representar, pero como ahora ocupa dos páginas cada letra (sólo de alto, no toda la página completa), para que todo encaje en su lugar usé un simple sumador para cada eje.

Vamos a imaginar que imprimimos el caso más sencillo, arriba del todo a la izquierda que es el punto (0,0). El ancho son 32 bytes (del 0 hasta 31) y de alto ocupa dos página (del 0 al 1). Lo de "página" puede sonar confuso, pero es simplemente la altura (8 píxeles de alto) y vamos a imprimir 16 píxeles de alto, por eso ocupa dos zonas (o páginas).

Entonces el punto inicial es (0,0) y el final es (31,1).  Ese "(31,1)" siempre va a ser fijo en nuestros cálculos porque es el área total a representar si partimos de (0,0).

Ahora vamos a imagina que quiero representar los números a partir del pixel 44 y hacerlo a partir de la página 2, pues el (x0, y0) vale eso mismo (44,2), porque es ahí donde comienza el barrido de bytes/píxeles (recuerda que son 8 píxeles verticales), pues para que todo siga en su lugar con la acotación de pantalla que necesitamos, sólo hay que sumar lo que ya teníamos en (x1,y1) más los que hay en (x0,y0), es decir, que tendremos en este caso esta configuración:

(44, 2), (44+31, 1+2). De esta forma todo sigue en su sitio en el lugar que queramos (siempre que no nos pasemos de los márgenes).

En programación esto funciona con una filosofía muy parecida y quien se haya metido a representar píxeles seguramente le será muy familiar estos conceptos. Yo apenas sé de gráficos, pero hace muchos años hice pequeñas pruebas en BASIC y no pasaban de eso, simples pruebas para curiosear y poco más, sin embargo esos conceptos básicos ahora me han servido para aplicarlo de forma electrónica. Moraleja: Todo lo que experimentes, por tonto o simple que sea, quizás un día te servirá para algo.

Adjunto proyecto.

Saludos.

PD: Pongo algunas páginas que he estado consultando:

1.) https://saber.patagoniatec.com/2019/08/ssd1306-oled-display-arduino-tutorial/

2.) https://robotcantalk.blogspot.com/2015/03/interfacing-arduino-with-ssd1306-driven.html

3.) https://iotexpert.com/2019/08/07/debugging-ssd1306-display-problems/

[ANDRES AMAUTA GONZALESZAPATA]

Gracias Democrito por compartir tus diseños digitales!!

--

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/9bc15088-c96d-4ed9-b09b-861ddd05d030%40googlegroups.com.

Advertencia legal: 

Este mensaje y, en su caso, los archivos anexos son confidenciales, especialmente en lo que respecta a los datos personales, y se dirigen exclusivamente al destinatario referenciado. Si usted no lo es y lo ha recibido por error o tiene conocimiento del mismo por cualquier motivo, le rogamos que nos lo comunique por este medio y proceda a destruirlo o borrarlo, y que en todo caso se abstenga de utilizar, reproducir, alterar, archivar o comunicar a terceros el presente mensaje y ficheros anexos, todo ello bajo pena de incurrir en responsabilidades legales. Las opiniones contenidas en este mensaje y en los archivos adjuntos, pertenecen exclusivamente a su remitente y no representan la opinión de la Universidad de Cuenca salvo que se diga expresamente y el remitente esté autorizado para ello. El emisor no garantiza la integridad, rapidez o seguridad del presente correo, ni se responsabiliza de posibles perjuicios derivados de la captura, incorporaciones de virus o cualesquiera otras manipulaciones efectuadas por terceros.

[charli va]

Que gran explicación democrito!! Oye una pregunta te gustaría que esto formara parte de la colección icecrystal? La idea de esa colección era añadir todo tipo de displays gráficos. 

Si te apetece dímelo y te doy permisos al repositorio para que puedas ir añadiendo los diseños documentación...

Como te digo solo si te apetece!

--

[Democrito]

Zupay: Un placer siempre!

Charli: Este fin de semana te hago un PR y subo varios cacharros! Gracias por el ofrecimiento!

[charli va]

Tranquilo! Te hago colaborador y así metes mano a tu ritmo! Te mando luego la invitacion

El El lun, 27 ene 2020 a las 9:47, Democrito <spo...@gmail.com> escribió:

Zupay: Un placer siempre!

Charli: Este fin de semana te hago un PR y subo varios cacharros! Gracias por el ofrecimiento!

--

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/803a70b3-e36d-4eeb-b6fc-3f72c85b0c0a%40googlegroups.com.

[Diego Harosteguy]

Muy bien Democrito!, geniales los avances!!

Saludos.

[Democrito]

Gracias Diego!

[Obijuan]

¡Genial Demócrito!

Lo acabo de probar y va... super bien!!!!!!!! :-)

Este proyecto se está poniendo muy muy interesante!!!!  ¡Muchísimas gracias!

Saludos, Obijuan

[Democrito]

Obijuan, muchas gracias por la prueba y foto!

[charli va]

Ahí va mi prueba! Demócrito vas onfire!

El mar., 28 ene. 2020 a las 10:25, Democrito (<spo...@gmail.com>) escribió:

Obijuan, muchas gracias por la prueba y foto!

--
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/202a2945-0c5b-4e3a-adc3-ed68c433dc04%40googlegroups.com.

[Democrito]

Moolaa! Muchas gracias Charli!

[Democrito]

Hola de nuevo,

Sobre el proyecto anterior he sustituido el CLS por un "skin" (piel), es decir, que dejo un fondo de pantalla y luego pongo a contar el contador. Cualquier cosa que "dibujemos" en la pantalla queda ahí memorizado y sólo si añades datos se sobre-escribe encima. Esto da mucho juego como presentación en cualquier proyecto.

Os pongo un vídeo de ejemplo: https://www.youtube.com/watch?v=zfTCC-rX9n0

Y adjunto los cambios realizados.

Saludos.

[charli va]

Que máquina Demócrito! esto cada vez pinta mejor!!!

--

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/43750c3b-7739-4f4b-a97c-cc2c16247428%40googlegroups.com.

[Jose Pico]

 Que pasada! 

 Me encanta!

 Muchas Gracias Demócrito!

 Estoy viendo el ping pong de Juanma funcionando en la OLED ! jejejejeje

 Saludos

El jueves, 30 de enero de 2020, 14:28:40 (UTC+1), charliva escribió:

Que máquina Demócrito! esto cada vez pinta mejor!!!

El jue., 30 ene. 2020 a las 13:24, Democrito (<spo...@gmail.com>) escribió:

Hola de nuevo,

Sobre el proyecto anterior he sustituido el CLS por un "skin" (piel), es decir, que dejo un fondo de pantalla y luego pongo a contar el contador. Cualquier cosa que "dibujemos" en la pantalla queda ahí memorizado y sólo si añades datos se sobre-escribe encima. Esto da mucho juego como presentación en cualquier proyecto.

Os pongo un vídeo de ejemplo: https://www.youtube.com/watch?v=zfTCC-rX9n0

Y adjunto los cambios realizados.

Saludos.

--
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-lado-libre+unsubscribe@googlegroups.com.

[Democrito]

José, ojalá! De hecho el ping pong de Juanma fue uno de los proyectos más épicos que he visto hasta el día de hoy.

[Juanma Rico]

Cuando queráis nos ponemos a ello... yo encantado de participar...  ;))

Saludos
Juan Manuel Rico

[Obijuan]

Brutal!! Es brutal!!

¡Gracias! 😃

Ya estoy visualizando los plugins para acceder a la Oled... 😀

Saludos, Obijuan

[Democrito]

Os traigo otra pequeña tontería que dice mucho sobre el consumo de las pantallas OLEDs. He alimentado la oled desde los pines I/O de la FPGA y funciona! jejeje. Eso sí, se ve con mucha menos luminosidad. En la imagen parece normal, pero en la realidad el brillo es bastante apagado.

Podéis comprobar la conexión directa.

En Oleds de píxeles azules la conexión va a así: VCC - GND - SCL - SDA

Y para las Oleds de píxeles blancos hay que enrocar las patillas VCC y GND, porque tiene esta configuración de pines: GND - VCC - SCL - SDA.

Saludos.

[Democrito]

Hola,

Hace unos meses publiqué un editor serie para la pantalla Oled. Era muy sencillito pero funcional. He vuelto a ese proyecto con la intención de mejorarlo y se le parezca a un editor también sencillo pero con un funcionamiento más natural. Lo más importante es que tiene scroll, esto significa que vamos escribiendo y pulsando entrer cuando toca, y cuando llega abajo del todo, las siguientes líneas subirán hacia arriba y el nuevo texto queda allí abajo.

Si echáis un ojo al circuito, dentro del módulo que veís en la imagen de arriba veréis esto:

Es un módulo con muchas complejidades, y es un reto que necesitaba experimentar para seguir aprendiendo. No uso en ningún momento comandos que tiene la Oled para automatizar acciones concretas, sólo cuando vuelco la memoria en ella. La intención real no es hacer un editor en sí, sino hacer un ejercicio de gestión de la memoria, es un reto además de interesante, bastante importante para futuros proyectos más serios.

Me inventé un modo de hacer el scroll sin necesidad de copiar en otra memoria auxiliar lo que tenía que moverse hacia arriba. El concepto es muy simple, pero explicarlo con imágenes y texto sería tedioso; son esas cosas que si tienes a la persona delante con una libreta y lápiz se comprende fácilmente las secuencias  que van sucediendo, pero que a la hora de explicarlo por un medio como este se vuelve... bastante tedioso. De todas formas, si alguien le interesa este tema que lo diga y veré cómo plasmarlo.

Hay más detalles en ese circuito, no sólo el scroll. Por ejemplo, hay que borrar de la memoria todo lo que se escribe como nuevo, a partir del último carácter escrito hasta el final de la línea.

El trabajar directamente con la memoria nos permite hacer cosas a una velocidad vertiginosa. Por ejemplo, el anterior editor trabajaba a una media de 9600 baudios, y si le apretabas mucho fallaba. Esto sucedía porque ese editor estaba basado en comandos que le enviaba a la Oled. Los envíos de datos a la Oled son lentos (velocidad I2C) y para cuando recibía un carácter por el puerto serie, convertirlo en 8 bytes y enviarlo a la Oled... pues "se pillaba los dedos" y por eso los baudios eran tan bajos. Al trabajar directamente con una memoria (de la propia FPGA) todo se puede acelerar tanto que este nuevo editor admite recepciones de 250000 baudios. Sólo cuando vuelco la memoria es cuando llamo a la Oled.

No está terminado, me quedan cosas por hacer y espero que me cunda en estos días que viene para darlo por finalizado. Me queda por hacer comandos que por ejemplo, borre la pantalla, poder elegir colocar el texto en una zona de la pantalla e integrar el proyecto de dibujar líneas.

Adjunto Zip.

Saludos. 

[Democrito]

Hará unas semanas recibí unas pantallas Oled que son un poco más grande que la que tenía. Antes estaba usando Oled de 0,96 pulgadas y ahora manejo de 1,3 pulgadas. Aunque no es mucho, se nota la diferencia. Ahora los caracteres de 8x8 los leo perfectamente.

[Jose Pico]

Magnífico!

Un gran avance!

Sigue así!

Gracias.

El El vie, 27 mar 2020 a las 21:52, Democrito <spo...@gmail.com> escribió:

Hará unas semanas recibí unas pantallas Oled que son un poco más grande que la que tenía. Antes estaba usando Oled de 0,96 pulgadas y ahora manejo de 1,3 pulgadas. Aunque no es mucho, se nota la diferencia. Ahora los caracteres de 8x8 los leo perfectamente.

--
Has recibido este mensaje porque estás suscrito a un tema del grupo "FPGAwars: explorando el lado libre" de Grupos de Google.
Para cancelar la suscripción a este tema, visita https://groups.google.com/d/topic/fpga-wars-explorando-el-lado-libre/lea8VkKIhV4/unsubscribe.
Para cancelar la suscripción a este grupo y a todos sus temas, 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/b5668006-9afb-408c-ae9e-7aa092dc2c5b%40googlegroups.com.

[Diego Harosteguy]

Que bueno Democrito!, has avanzado enormemente con este proyecto!.

Muchas gracias por compartir!.

[Diego Harosteguy]

Acá la prueba!!!, me encanta!! funciona super veloz!

[Democrito]

Muchísimas gracias Diego por la prueba!

Y gracias por los comentarios Diego y José.

Un abrazo a los dos!

[Diego Harosteguy]

Le incorpore el modulo esp8266-esp01  wifi en el que estoy trabajando (todavia todo muy básico lo mio)...

Dejo un videito con la prueba, es emocionante

https://youtu.be/_6gd-manoik

Vemos como la fpga comienza tomar independencia, jaja

Saludos!!

[Democrito]

Madre mía Diego, qué pasada!!!!

Te agradezco un mogollón este tipo de prueba.

Un abrazo muy fuerte!

[Diego Harosteguy]

Sii, es muy bueno esto!! da animo a seguir aprendiendo!!.

Abrazo!.

[charli va]

Sois la leche!!!! Que grandes los dos!!!

Eso es Democrito has dado con la clave. En icecrystal gestionó así las cosas también. Pasando de los comandos lcd si tú te montas todo con tu memoria y solo vuelcas vas a toda leche!

Grandes avances!!!

--

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/7cd4b349-431d-49eb-a3d7-9039cf78bf9e%40googlegroups.com.

[Obijuan]

Woala!!!!!!! Cómo mola!!!!!  Esto es un super avance!!!!!!!!!!!!!

Muchísimas gracias!  :-)

Saludos, Obijuan

El domingo, 15 de diciembre de 2019, 22:55:52 (UTC+1), Democrito escribió:

[Alberto Nicas]

Búa Democrito... eres un crack trasteando por el foro he visto esto y que buen aporte, no lo conocía!!! realmente esto abre muchísimas posibilidades, es un tema antiguo, pero digno de subir de nuevo :)

El domingo, 15 de diciembre de 2019 a las 22:55:52 UTC+1, Democrito escribió:

Hola!

He conseguido poner en marcha una pantalla Oled I2C (SSD1306) de 128x64 píxels. Es sólo un acercamiento a su funcionamiento más elemental. El circuito que he diseñado saca una tabla ASCII un poco diferente a la tradicional que todos conocemos, lo hace como si fuese una imagen completa de ella.

Como podéis comprobar las luces leds y las cámaras no se llevan bien y se ve todo borroso; además de que hay que tener buena vista con la pantalla en vivo.

En realidad se vería esto:

El circuito general me ha quedado así:

Como decía (estoy avisando) el circuito de momento sólo es capaz de sacar una imagen pre-grabada en un fichero (en formato hexadecimal). Todavía no puede escribir texto ni números y menos todavía poner esos caracteres en una zona de la pantalla.

Mientras iba haciendo a la vez iba comprendiendo los pasos que tenía que dar, muchas veces he tenido que dar varios pasos atrás porque iba por mal camino.

Quizás más adelante intento hacer que se pueda manejar como si fuese un LCD de toda la vida, pero electrónicamente hablando es bastante complejo hacer eso.

He de agradecer a un autor (o autores) sus explicaciones de cómo hacer funcionar una pantalla Oled sin librerías. Si le echáis un vistazo sabréis tanto como yo sobre su funcionamiento que podréis aplicar lo aprendido tanto a Arduino como a FPGAs y en castellano. Esta es la web:

https://robologs.net/2018/03/11/como-conectar-una-pantalla-oled-ssd1306-con-arduino-sin-libreria/

Estaré usando imágenes pertenecientes a esa misma web. Por cierto, uso exactamente el mismo tipo de pantalla Oled que la que usan en esa web. Allí lo explica todo con todo lujo de detalles.

Adjunto el proyecto como zip porque además del ICE contiene un archivo de configuración y otro donde está toda la tabla ASCII (como imagen) a representar.

Sería muy largo de explicar cómo funciona el circuito pero voy a hacerlo muy resumido y comentado lo más importante o clave.

En general es importante conocer estas premisas:

Cada vez que quieras llamar a la pantalla Oled lo primero de todo es poner su dirección. La mía tiene como dirección 3C (son 7 bits), falta el bit más bajo (para hacer un byte) que es el de lectura o escritura, y como siempre vamos a escribir, ese bit siempre será 0. Entonces, si 3C es en binario 0111100 (7 bits en total), al añadir el bit más bajo como 0, nos queda: 01111000, es decir, 78 en hexadecimal. Si fuésemos a lee (pero este no es el caso) entonces la dirección sería 79, ya que el bit más bajo valdría 1 (para poder leer).

Después de enviar el byte de dirección viene un byte de comando. Sólo vamos a necesitar conocer dos comandos el 00 y el 40.

* 00 Lo enviamos para decirle a la pantalla Oled que todo los bytes que reciba después de éste son comandos de configuración de la pantalla Oled.

* 40 Lo enviamos para decirle a la pantalla Oled que todo los bytes que reciba después son para escribir en la pantalla. Lo hará en forma de píxels en grupos de 8 y en vertical. En esta imagen se ve perfectamente la idea:

Se comprende que después de enviar 78 y 40 los siguientes bytes se imprimen como 8 píxels verticales. Cada vez que reciba la pantalla Oled un nuevo byte se pasa a la siguiente columna de píxels automáticamente. Como esta pantalla es de 128x64 píxels, cuando llegue a la columna 127 (comienza en 0) y quiera pasar a la siguiente, volverá al comienzo y 8 píxels más abajo. Todo esto lo hace automáticamente, es su forma de funcionar con la configuración que le metí.

Ahora bien, ¿cómo sabe la pantalla Oled cuándo comienza o termina una ristra de datos, ya sea para configurar o para pixelar? La respuesta está en el protocolo I2C. Cuando vamos a enviar datos de comandos o píxels, antes hay una señal de "start" y cuando termina de enviar datos hay una señal de "stop".

Los dos ficheros de extensión ".list" son los datos que irán almacenados en dos memorias (las estoy usando como si fuesen ROM, aunque se puede escribir sobre ellas). Una de las memorias es de 32 bytes, y la otra es de 2 Kbytes.

Por el tipo de diseño que he hecho gestiono la memoria de una forma un poco particular. Uso dos bytes (que nada tiene que ver con la pantalla Oled, sino que son necesidades del circuito) para saber cuánta información voy a enviar, de esta manera sé cuándo he de enviar la señal de "start" y "stop" del I2C. Y después viene el volumen de datos real para la pantalla Oled. Si abres cualquier de los dos ficheros con un editor de texto, verás las explicaciones de qué es cada cosa. En "font.list" tuve que trocear el envío de información en bloques de 100 bytes aproximadamente (cantidad arbitraria, es decir, tomaba 100 por comodidad para mí) porque de otra manera (todo de un golpe) me daba error.

Saludos.

[Democrito]

Hey Alberto!

Las OLEDs (y en general, todo lo que sea representación gráfica en el medio que sea) es todo un Universo (apasionante), pero en el que todavía hay mucho por hacer...

Gracias y un abrazo!

[Miguel Ginard]

Wow! Qué nivel 😍
Gacias