Pantallas Serie Digole: Manegar la pantalla serie de Digole en los modos UART, I2C y SPI con un ODROID-C1+

Digole Display

Digole.com ofrece múltiples pantallas serie inteligentes que se controlan por medio de un completo conjunto de comandos exclusivos de alto nivel. Estos comandos facilitan el trazado de gráficos complejos y la visualización de imágenes y video, proporcionando una capa de abstracción que ayuda a exportar sus pantallas a un gran número de plataformas. Quizás lo más útil es que todos los modelos de pantallas serie se controlan de la misma forma, con el mismo conjunto de comandos de alto nivel, y siendo su firmware actualizable. El manual de usuario de http://bit.ly/2fXiD9y proporciona una información completa de todos los comandos disponibles.

Para este artículo, utilicé un Módulo Digole serie de 1,8 pulgadas UART/I2C/SPI a color 160×128 OLED con 2MB Flash, número de modelo DS160128COLED-46F. Este modelo no tiene luz de fondo o pantalla táctil como algunas otras pantallas transistores de película delgada (TFT). Si compras un modelo diferente, puede que tengan que modificar el código fuente para cambiar la resolución de la pantalla.

Figura 1 – Prueba mandel.c de Dougherty en modo SPI de 3 hilos. Las líneas de barrido que se observa en las fotos no son visibles para el ojo humano.

Todo lo que aparece a continuación se llevó a cabo en un ODROID-C1+ ejecutando la imagen mínima oficial de Ubuntu 16.04 e iniciando sesión como root.

Prueba inicial a través de la conexión serie UART

La pantalla serie Digole transmite en modo UART (conectores SPI y I2C abiertos). Siempre es de 8 bits, sin bit de paridad, 1 bit de parada. La velocidad de transmisión inicial configurable por el usuario es de 9600.

Con el ODROID apagado, realiza las siguientes conexiones por cable:

Digole VCC = 5V GPIO pin 2 Digole GND = Ground GPIO pin 6 Digole DATA = TXD1 GPIO pin 8

Enciende el ODROID. El Digole debería pasar inmediatamente por su propio proceso de arranque, que implica una prueba RGB y finaliza con una línea de texto. Mi pantalla mostraba “UART baud: 9600 V4.1V + 2MB Flash”. V4.1V es la versión de firmware, 2MB Flash es la cantidad de memoria flash disponible en este modelo de pantalla en particular. No todos los modelos tienen memoria flash.

Ajusta la velocidad de transmisión del dispositivo UART:

$ stty -F /dev/ttyS2 9600
Limpia la pantalla con:
$ echo “CL” > /dev/ttyS2
For this next command, use single-quotes–not smart-quotes or backticks–so that the \x00 terminator is handled correctly:
$ echo -n -e ‘TTHello ODROID\x00’ > /dev/ttyS2
$ echo “CL” > /dev/ttyS2
Dibuja un cuadrado de 45px x 45px::
$ echo -n -e ‘DR\x00\x00\x2D\x2D’ > /dev/ttyS2
Puesto que esto es una simple prueba, no necesitamos aprender la sintaxis de coordenadas de Digole por ahora.

Llegados a este punto, la pantalla es completamente funcional. Es posible utilizar los comandos exclusivos de Digole para controlar totalmente la pantalla simplemente haciendo eco al dispositivo UART. Esto significa que podemos escribir una aplicación o un juego totalmente en Bash o en cualquier otro lenguaje de programación que pueda transmitir directamente al dispositivo UART, incluyendo PHP, Perl, Ruby y Python, aunque probablemente con una velocidad de transmisión más alta. Con este planteamiento, se puede evitar la codificación en C y hacer uso de la librería C de Digole.

Vamos a probar otros métodos de conexión en serie, así que apaga el ODROID y retira la fuente de alimentación para cortar la energía a la pantalla Digole, después retira las conexiones de Digole a los pines GPIO.

Conexión serie I2C

Utilizando un soldador con una pequeña punta cónica, salté con cuidado el conector I2C mientras dejé abierto el conector SPI. Es importante no soldar ambos conectores uniendo las tres almohadillas. Esto requiere tener mucha precisión o un microscopio y una mano muy firme. Con el ODROID apagado, realiza las siguientes conexiones por cable:

VCC Digole = Pin 2 GPIO 5V GND Digole = Pin 6 GPIO puesta a tierra DATA Digole = Pin 3 GPIO I2CA_SDA CLK Digole = Pin 5 GPIO I2CA_SCL

Ten en cuenta que el manual de usuario tiene diagramas con resistencias de 10K o más entre VCC y DATA y VCC y CLK, pero los ejemplos de diagramas de código de la página web no tienen resistencias. Observé que funcionaba bastante bien sin las resistencias, así que no realice pruebas para ver si las resistencias funcionaban.

A continuación, enciende la pantalla. Si soldaste el conector I2C correctamente, la prueba de inicio indicará “Dirección I2C: 0x27 …” La prueba de arranque no parece saber si DATA y CLK están cableados correctamente.

Habilitar I2C en el ODROID ejecutando:

$ modprobe aml_i2c
Para probar I2C, usaremos el código C de ejemplo de Digole proporcionado en http://bit.ly/2xh29MJ.

El código de ejemplo fue escrito por Javier Sagrera para la Raspberry Pi. Podemos modificarlo para el ODROID con unos pequeños cambios; nada importante, simplemente renombrar algunas referencias a la Raspberry Pi y corregir unos cuantos errores ortográficos, tal como se muestra a continuación:

// Pin-out using I2C
// ODROID – Digole LCD
// 1: 5v = 5: VCC
// 3: SDA0 = 4: DATA
// 5: SCL0 = 3: CLK
// 6: GND = 1: GND
/*

// Communication set up command
* "SB":Baud (ascII bytes end with 0x00/0x0A/0x0D) -- set UART Baud Rate
* "SI2CA":Address(1 byte <127) -- Set I2C address, default address is:0x27
* "DC":1/0(1byte) -- set config display on/off, if set to 1, displayer will display current commucation setting when power on

// Text Function command
* "CL": -- Clear screen--OK
* "CS":1/0 (1 byte)-- Cursor on/off
* "TP":x(1 byte) y(1 byte) -- set text position
* "TT":string(bytes) end with 0x00/0x0A/0x0D -- display string under regular mode

// Graphic function command
* "GP":x(1byte) y(1byte) -- set current graphic position
* "DM":"C/!/~/&/|/^"(ASCII 1byte) -- set drawing mode--C="Copy",! and ~ = "Not", & = "And", | = "Or", ^ = "Xor"
* "SC":1/0 (1byte) -- set draw color--only 1 and 0
* "LN":x0(1byte) y0(1byte) x1(1byte) y2(1byte)--draw line from x0,y0 to x1,y1,set new pot to x1,y1
* "LT":x(1byte) y(1byte) -- draw line from current pos to x,y
* "CC":x(1byte) y(1byte) ratio(byte) -- draw circle at x,y with ratio
* "DP":x(1byte) y(1byte) Color(1byte) -- draw a pixel--OK
* "DR":x0(1byte) y0(1byte) x1(1byte) y2(1byte)--draw rectangle, top-left:x0,y0; right-bottom:x1,y1
* "FR":x0(1byte) y0(1byte) x1(1byte) y2(1byte)--draw filled rectangle, top-left:x0,y0; right-bottom:x1,y1
*/

#include < stdlib.h >
#include < linux/i2c-dev.h >
#include < fcntl.h >
#include < string.h >
#include < sys/ioctl.h >
#include < sys/types.h >
#include < sys/stat.h >
#include < unistd.h >

int main(int argc, char **argv)
{
int fd;
char *fileName = "/dev/i2c-1"; // Name of the port we will be using
int address = 0x27; // Address of I2C device
char buf[100];

if ((fd = open (fileName, O_RDWR)) < 0) { // Open port for reading and writing
printf("Failed to open i2c port\n");
exit(1);
}

if (ioctl(fd, I2C_SLAVE, address) < 0) { // Set the port options and set the address of the device printf("Unable to get bus access to talk to slave\n"); exit(1); } if (argc>1) {
sprintf(buf,argv[1]);
//printf("%s %d %s\n",buf,strlen(buf),buf[strlen(buf)]);
if ((write(fd, buf, strlen(buf)+1)) != strlen(buf)+1) {
printf("Error writing to i2c slave\n");
exit(1);
}
} else {
printf(" Simple tool to send commands to Digole graphic adapter\nexamples:\n");
printf(" digolei2ctest \"CLTTHello ODROID\" - Clear the screen (CL) and prints \"Hello ODROID\" (TT)\n");
printf(" digolei2ctest \"CC002\" - Draws a circle at x=30 (0), y=30 (0) with a radius of 32 (2)\n"); //not for Character LCD
}

return 0;
}
Guarda el código fuente anterior como digolei2ctest.c, luego compílalo:
$ gcc -o digolei2ctest digolei2ctest.c
A continuación, puedes ejecutarlo para enviar comandos (varios aparecen en los comentarios):
$ ./digolei2ctest "CLTTHello ODROID"
$ ./digolei2ctest "CC002"
Una vez más, puede utilizar todos los comandos de alto nivel disponibles en el Manual de usuario.

Nota: I2C es el único medio de comunicación con la pantalla serie Digole que es capaz de comunicarse de forma bidireccional. Teniendo en cuenta que únicamente estamos dibujando en la pantalla, la función de recepción de datos no se hace necesaria, pero I2C sí que es necesaria para acceder a la pantalla táctil.

A continuación, probaremos el método de comunicación SPI. Este es el más rápido, pero también el más complicado, de los métodos serie disponibles. Una vez más, apaga el ODROID y retira el enchufe de alimentación para apagar la pantalla Digole, luego desconecta las conexiones entre el ODROID y la pantalla Digole.

Conexión serie SPI de 3 hilos

Usando un soldador con punta cónica, retira cuidadosamente la soldadura del conector I2C y reemplázala soldando el conector SPI en su lugar. Una vez más, asegúrate de no soldar ambos conectores uniendo las tres almohadillas. Con el ODROID apagado, realiza las siguientes conexiones por cable:

VCC Digole = Pin 2 GPIO 5V GND Digole = Pin 6 GPIO puesta a tierra DATA Digole = Pin 9 GPIO MOSI_PWM1 CLK Digole = Pin 23 GPIO SPI_SCLK SS Digole = Pin 24 GPIO (#117) SPI_CEN0

Figura 2 – Cableado SPI instalado

Enciende el ODROID. El texto de inicio de Digole debería empezar por “SPI Mode: 0 …” si soldaste el conector SPI correctamente. No parece saber si DATA, CLK o SS están cableados correctamente

Ten en cuenta que Digole menciona en el manual que el modo SPI tiene el requisito adicional de un “sistema especial de conexión” para “sincronizar los datos”. Para más detalles echa un vistazo al “Diagrama de flujo de datos del transmisor receptor SPI” al final de la sección sobre Conexión del puerto del manual de usuario de la pantalla Digole. Para las pruebas SPI, usaremos el código de ejemplo y el controlador de James F. Dougherty disponible en http://bit.ly/2wmyPIi.

Este script también está escrito para la Raspberry Pi, aunque funciona sin tener que hacer modificaciones sobre el ODROID-C1 +. La única diferencia es la disposición de los pines: conecta el pin SS de Digole al pin 24 GPIO del ODROID-C1+ en lugar del pin 26 GPIO en una Raspberry Pi.

Habilita SPI en el ODROID:

$ modprobe spicc
Luego obtener y compilar el controlador SPI de Dougherty:
$ git clone https://github.com/jafrado/digole.git
$ cd digole
$ make
Ejecuta el código de prueba incluido:
$ ./oledtest /dev/spidev0.0
Deberías ver que en la pantalla aparece una imagen de una brújula seguida de muchas pantallas de prueba. No te preocupes por la lenta velocidad de dibujo, describiremos una forma de aumentarla en la siguiente sección. Prueba el otro programa de ejemplo para mostrar un fractal de Mandelbrot:
$ ./mandel /dev/spidev0.0
Existen más programas de ejemplo, pero parecen estar plagados de errores y tienden a trazar gráficos en posiciones impredecibles. Llegados a este punto, entre los programas oledtest.c y mandel.c, deberías tener todo lo necesario para empezar a crear tus propias aplicaciones que utilicen las pantallas serie Digole.

Cuestiones relacionadas con el rendimiento

En el código de Dougherty, cambie el valor spi_speed en la línea 41 de rpi_spi.c de 200,000 a 1,000,000 (1MHz) para aumentar la velocidad con la que se muestran las imágenes en pantalla. Si se supera el 1MHz se interrumpen los comandos de dibujo en el ODROID-C1+. Dougherty comentaba en el código que no fue capaz de superar los 200KHz, aunque en su caso estaba usando una lenta Raspberry Pi Zero en las pruebas.

Es curiosa esta limitación, yo utilicé un simple bucle while con un comando “sleep x” y fui variando los valores de x con el fin de agobiar la pantalla de Digole enviando sentencias de comandos rápido y continuadamente, dando lugar a gráficos mal dibujados o imágenes corruptas, que es exactamente lo que sucede cuando el valor “spi_speed” se incrementa por encima de 1MHz en los programas de ejemplo de Dougherty. En teoría, el bus SPI y la pantalla Digole pueden ir mucho más rápido que 1MHz, pero sospecho que el ya mencionado “sistema especial de conexión” y la gestión precisa de las comunicaciones SPI a nivel de palabra y byte serán necesarios para alcanzar el máximo rendimiento.

Sabemos, sin embargo, que estas pantallas son capaces de funcionar muy bien. Digole aparece en un video de YouTube en http://bit.ly/2wfwPRJ el cual muestra una rápida secuencia de video de 27 fotogramas en aproximadamente 2 segundos, que es aproximadamente 14fps.

Desafortunadamente, en el video no se detalla cómo se ha alcanzado esta velocidad. El título del video indica que han utilizado la relativamente nueva función Video Box (a partir del firmware V4.0V) que permite escribir datos de imagen raw directamente en la pantalla. En el Manual del Usuario se dice que la función Video Box funciona a “máxima velocidad: el modo UART-460800bps, I2C-> 400K bps, SPI-10MHz.” Eso es diez veces más rápido que nuestro actual mejor rendimiento alcanzado usando los ejemplos de Dougherty en modo SPI. Es probable que necesites ponerte en contacto con el soporte técnico de Digole para saber cómo conseguirlo.

En relación a las pruebas de bucle while, el comando “sleep 0.05” parece ser el retardo más corto que “TP00TTHello ODROID \ x00” envía, dando como resultado un parpadeo apenas perceptible de las palabras “Hello ODROID” que se vuelven a trazar sin errores. Para muchos proyectos, especialmente en los que se debe actualizar el texto periódicamente, 0.05 segundos es lo suficientemente rápido, y no necesitamos lidiar con la puesta a punto del rendimiento de las comunicaciones serie.

Conclusiónn

Estoy bastante impresionado con las pantallas serie de Digole por sus múltiples métodos de conexión y sus fáciles, aunque potentes comandos. Tienen muchas características avanzadas, incluyendo fuentes almacenadas, secuencias de comandos almacenadas y pantalla táctil integrada que otras pantallas menos inteligentes simplemente no tienen. La mayoría de las pantallas táctiles son un dispositivo independiente de la pantalla, pero la pantalla táctil Digole se controla a través de la misma interfaz serie que la pantalla. La cuestión es que no hay muchas pantallas de este tamaño a color y con altas resoluciones, especialmente en OLED.

Espero que estas diminutas pantallas a todo color terminen formando parte de muchos proyectos ODROID, especialmente de proyectos portátiles que funcionen con pilas. Esto es así para los modelos con pantalla táctil resistiva y un puñado de modelos TFT con retroiluminación regulable. Los modelos OLED no tienen luz de fondo para atenuarlos, aunque la reducción de la luminosidad puede lograrse cambiando los colores a tonos más oscuros.

El rendimiento de las pantallas serie Digole es lo suficientemente bueno para usarla en la mayoría de los casos sin tener que llevar a cabo ajustes de rendimiento. Para los juegos y el video donde es importe la velocidad de los fotogramas, por supuesto que es posible lograr un rendimiento aceptable por medio de la gestión de las comunicaciones serie y aprovechando las características avanzadas de la propia pantalla.

Be the first to comment

Leave a Reply