placa de evaluación de pantallas de tinta electrónica para...

1

Autor: Javier Chamizo Angulo

Tutor: Manuel Ángel Perales Esteve

Trabajo Fin de Grado Grado en Ingeniería de Tecnologías Industriales

Dep. de Ingeniería Electrónica Escuela Técnica Superior de Ingeniería

Universidad de Sevilla Sevilla, 2017

Placa de evaluación de pantallas de tinta electrónica para microcontroladores de gama media

3

Trabajo Fin de Grado Grado en Ingeniería de Tecnologías Industriales

Placa de evaluación de pantallas de tinta electrónica para microcontroladores de gama

media

Autor:

Javier Chamizo Angulo

Tutor:

Manuel Ángel Perales Esteve

Profesor Contratado Doctor

Dep. de Ingeniería Electrónica

Escuela Técnica Superior de Ingeniería

Universidad de Sevilla Sevilla, 2017

5

Trabajo Fin de Grado: Placa de evaluación de pantallas de tinta electrónica para microcontroladores de gama media

Autor: Javier Chamizo Angulo Tutor: Manuel Ángel Perales Esteve

El tribunal nombrado para juzgar el Proyecto arriba indicado, compuesto por los siguientes miembros:

Presidente:

Vocales:

Secretario:

Acuerdan otorgarle la calificación de:

Sevilla, 2017 El Secretario del Tribunal

7

ÍNDICE

Índice 7

Glosario de siglas 9

1 Introducción 10

1.1 Tipos de displays/pantallas 10

1.1.1 Display de segmentos 10

1.1.2 LCD (Liquid Crystal Display) 11

1.1.3 Tinta Electrónica 11

1.2 Objetivos y alcance del proyecto 12

1.3 Estructura del documento 13

2 2.7 inch e-paper display 14

2.1 Conexiones 14

2.2 Sensor de temperatura LM75B 16

2.3 Comunicación entre display y microcontrolador 18

2.3.1 Formato del bus SPI 19

2.3.2 Escribir en memoria 23

2.3.3 Encendido del G2 COG driver- Encendido de pantalla 24

2.3.4 Inicialización del G2 COG driver 25

2.3.5 Escribir dato de la memoria al EPD 27

2.3.6 Apagar el G2 COG driver 34

2.3.7 Resumen final 34

3 Librerías y Funciones 35

3.1 Librerías básicas 37

3.1.1 I2C 37

3.1.2 SPI 38

3.2 Librería de actualización de pantalla 40

3.3 Librería gráfica 44

4 Resultados obtenidos 47


4.2 Librería gráfica 47

5 Trabajo futuro 51

8

6 Anexo A 52

6.1 Librerías básicas 52

6.1.1 I2C 52

6.1.2 SPI 55


6.3 Librería Gráfica 67

Referencias 73

9

GLOSARIO DE SIGLAS

FPL Front Plane Laminated

TFT Thin Film Transistor

FPC Flexible Printed Circuit

COG Chip On Glass. Hay dos versiones G1 y G2.

EPD E-Paper Display

EPD Module EPD con Tcon

Tcon Timing Controller

10

1 INTRODUCCIÓN

1.1 Tipos de displays/pantallas

Para empezar, analizaremos brevemente las distintas tecnologías de pantallas hasta llegar a la tinta electrónica, objeto de estudio de este trabajo.

1.1.1 Display de segmentos

El display de 7 segmentos es muy utilizado para representar números y algunas letras debido a su gran simpleza para controlar desde cualquier microcontrolador con suficientes pines GPIO.

Está compuesto por 7 segmentos leds que forman un “8”. De esta forma, controlando el encendido y apagado de cada led, podremos representar distintos caracteres. Además, también suelen incluir un octavo led que hace de punto decimal.

Existen dos tipos de display de 7 segmentos, su principal diferencia es la conexión que debemos implementar para encenderlos. Estos dos tipos se conocen como Ánodo común y Cátodo común.

En los 7 segmentos de Cátodo Común, el punto en común para todos los Led es el Cátodo (Gnd) mientras que en los de Ánodo común el punto de referencia es Vcc.

Imagen 1-1Conexión del display de 7 segmentos para cátodo y ánodo común (fuenteabierta.teubi.co)

Siempre es recomendable conectarle una resistencia en serie a cada led del 7 segmentos, la intensidad lumínica en este caso dependerá del valor de la resistencia agregada.

Para añadir precisión a los caracteres que se pueden obtener, estos displays evolucionan a displays de 14 y 16 segmentos, así como a una matriz de puntos leds. De esta manera se puede obtener mayor precisión en los caracteres, pero conforme aumenta el número de leds también aumenta el número de pines necesarios para manejarlos.

11

1.1.2 LCD (Liquid Cry�al Display)

El funcionamiento de los displays LCDs consiste en una fina capa de cristal líquido entre dos placas de vidrio y dos polarizadores de luz. En la parte inferior se sitúa una fuente de luz que puede ser un simple espejo (LCDs reflectivos), una fuente activa (LCDs transmisivos) o combinación de ambos (LCDs transreflectivos).

Este tipo de displays es también muy utilizado en el ámbito de proyectos electrónicos debido a su bajo consumo de energía. Sin embargo, presenta limitaciones como un ángulo de visión reducido comparado con otras tecnologías de displays y el contraste con el que se pueden representar los caracteres o imágenes.

Es más complejo de implementar que el display de 7 segmentos, pero proporciona mayor precisión y variación en los caracteres, así como mayor tamaño de pantalla, no quedando limitado a un caracter por display como en el caso de los 7 segmentos.

1.1.3 Tinta Ele�rónica

La tinta electrónica es una tecnología que permite crear pantallas planas, tan delgadas como un papel, y con una flexibilidad que permite que se puedan enrollar.

Esta tecnología de pantallas está constituida por tres capas, una con microtransmisores eléctricos que se encargará de polarizar la tinta electrónica, otra con la tinta electrónica y una tercera con una lámpara protectora.

La tinta electrónica consiste en unas cápsulas rellenas de un líquido viscoso y transparente en el que se introducen partículas de titanio blancas y negras con carga positiva y negativa respectivamente. De esta manera, si desde la capa con microtransmisores eléctricos se polariza positivamente, las partículas blancas serán repelidas y las negras atraídas, elevándose todas las partículas blancas a la superficie de la pantalla y consiguiendo una pantalla en blanco. Por lo contrario, con una polarización negativa se conseguiría mostrar el color negro. Alternando zonas de polarización positiva y negativa a lo largo de la pantalla se consigue representar distintas imágenes y caracteres.

Imagen 1-2 Sección de microcápsulas de tinta electrónica (www.elotrollado.net)

Como las partículas están cargadas y el líquido que rellena las cápsulas tiene una alta viscosidad, la posición de estas partículas dentro de las cápsulas se mantienen sin necesidad de mantener ninguna tensión eléctrica desde la capa con microtransmisores. Po lo tanto, al solo necesitar tensión para representar una imagen en pantalla y no para mantenerla, el consumo de energía es muy bajo.

http://www.elotrollado.net/

12

Por otra parte, por el mismo motivo, al ser un líquido viscoso, se necesita más tiempo de polarización desde la capa de microtransmisores para conseguir que se muevan las partículas cargadas. Esto se traduce en un elevado tiempo de actualización de pantalla, que es uno de las principales desventajas de la tinta electrónica en comparación con otras tecnologías de displays.

Las principales ventajas de la tinta electrónica son altas resoluciones, no necesita retroiluminación, amplio ángulo de visualización y perfectamente visible a la luz del Sol, además del bajo consumo de energía nombrado anteriormente.

Como desventajas, cabe nombrar además del elevado tiempo de actualización de pantalla explicado con anterioridad, el hecho de que es una tecnología en blanco y negro. En la actualidad se está desarrollando esta tecnología para imágenes a color, pero aún no está disponible. Sin embargo, a pesar de estos inconvenientes, es de gran utilidad en libros electrónicos y otras aplicaciones similares.

1.2 Objetivos y alcance del proyecto

El objetivo de este proyecto es diseñar las librerías y funciones necesarias para controlar una pantalla de tinta electrónica con el fin de acercarla al usuario. Es decir, se pretende que con esas librerías y funciones se puedan realizar acciones sobre la pantalla de manera intuitiva. Estas acciones son:

• Limpiar pantalla: borra todo resto de la imagen representada en la pantalla anteriormente y la deja en blanco.

• Dibujar imagen: borra lo que esté dibujado en pantalla y representa una nueva imagen guardada en memoria.

• Crear imagen: crear la imagen que después se representará en pantalla mediante gráficos simples tales como líneas y rectángulos. Además de estos gráficos simples, la posibilidad de incluir textos y números de diferentes fuentes y tamaños.

De esta manera se podrá crear la imagen que se desee representar en la pantalla mediante la combinación de otros elementos e imágenes sin necesidad de tener la imagen definitiva almacenada en memoria.

Otro apartado importante que se tratará será la conexión detallada entre la pantalla y el microcontrolador.

En este caso, la pantalla de tinta electrónica que se usará será el módulo que proporciona Ebedded Artists (2.7 inch e-paper display) el cual contiene la pantalla EM027BS013 de Pervasives Displays. Por otra parte, el microcontrolador será el MSP432P401R con el sistema de desarrollo MSP-EXP432P401R de Texas Instruments.

Con la pantalla y el microcontrolador fijados, se desarrollarán estas librerías y funciones partiendo de las bases teóricas aportadas por el fabricante, que describen las características tanto físicas y dimensionales de la pantalla como los métodos a seguir para tratar con ella desde el microcontrolador.

13

1.3 Estructura del documento

Tras esta primera sección en el que se introducen algunas de las tecnologías de pantallas presentes y se explica el funcionamiento de la tinta electrónica, en este subapartado se presenta la estructura de contenidos que va a seguir el trabajo:

En la sección 2, se abordará la pantalla de tinta electrónica específica que se va a usar en ente trabajo. Resolviendo las formas de conexión con el micro, la forma de tratar con el sensor de temperatura que incluye y los protocolos que serán necesarios seguir tanto para mandar los datos de imagen a la pantalla como para actualizar correctamente la imagen que se pretenda mostrar.

En la sección 3, se explicarán las funciones desarrolladas en cada librería, así como las librerías que se plantean. Se analizará cada función exponiendo su objetivo y sus argumentos de entrada y salida. Además, al principio de este apartado se incluyen brevemente algunas de las características del MSP432P401R Launchpad.

En la sección 4, se expondrá los resultados que obtenemos en la pantalla a partir de cada una de estas funciones.

Por último, en la sección 5 se plantearán posibles mejoras y ampliaciones que se podrán desarrollar en el futuro. Además, en el Anexo se adjunta el código de las funciones descritas en la sección 3.

14

2 2.7 INCH E-PAPER DISPLAY

El módulo que se usa en este proyecto es el 2.7 inch e-paper display de Embedded Artists, que contiene la pantalla de tinta electrónica EM027BS013 de Pervasives Displays.

Esta pantalla tiene una resolución de 117 pdi. Además, necesita muy poca potencia para cargar una imagen y ninguna para mantenerla, debido a las características de la tinta electrónica, ya comentadas en la introducción.

A continuación, se enumeran brevemente algunas de las características principales de esta pantalla de tinta electrónica, proporcionada por su datasheet [4]:

• Resolución: 264 x 176 píxeles • Muy bajo consumo • Amplio ángulo de visión • Extra delgada y ligera • SPI interface • Sensor de temperatura incluido

2.1 Conexiones

El módulo dispone de dos conectores de 14 pines y otro de 26 compatible con Raspberry PiTM:

Figura 2-1 Serial expansión connector [7]

15

Figura 2-2 Raspberry PITM Compatible pinning [7]

En estas dos figuras se representan los distintos conectores que posee el módulo EPD, indicando la señal que corresponde a cada pin.

A continuación, en esta tabla se muestra la lista de señales recogidas en los pines de ambos conectores de 14 pines y se relacionan con el pin del MSP432P401R que se conecta cada uno de ellos para el desarrollo de este proyecto:

MSP432P401R Launchpad Conector de 14 pines del display Pin Señal Pin Señal GND GND 1 GND 3V3 3V3 2 3.3 V P1.5 SPI-SCK 3 SCK P1.6 SPI-MOSI 4 MOSI P1.7 SPI-MISO 5 MISO P5.0 GPIO (SPI-SSEL) 6 SSEL P3.2 GPIO 7 Busy P3.3 GPIO 8 Border Control P6.5 I2C-SCL 9 SCL P6.4 I2C-SDA 10 SDA P2.5 GPIO 11 CS Flash P2.6 GPIO 12 Reset P2.4 GPIO 13 Panel on P2.3 GPIO 14 Discharge

Tabla 2-1 Conexión de pines entre MSP432P401R Launchpad y 2.7’’ e-paper display.

El microcontrolador que usaremos en este proyecto es el MSP432P401R con esl sistema de desarrollo MSP-EXP432P401T. Este micro tiene suficiente memoria RAM, por lo tanto, no es necesario usar memoria Flash y el pin CS flash no se utiliza.

Para la comunicación SPI se utilizan los pines P1.5, P1.6 y P1.7 del micro. Estos pines corresponden al módulo eUSCI_B0. En caso del I2C, los pines asignados son P6.4 y P6.5 correspondientes al módulo eUSCI_B1. El resto de señales se asocian a pines de la GPIO a excepción de la alimentación y la tierra.

En este caso se han elegido el eUSCI_B0 y el eUSCI_B1, pero se podrían haber elegido cualquiera que estuviera disponible. De la misma manera los pines de la GPIO se pueden cambiar por otros con la misma función, esta conexión no es más que un ejemplo particular de conexión entre MSP432P401R Launchpad y el módulo EPD. Se explicará con más detalles algunas de sus características en el apartado 3.

16

2.2 Sensor de temperatura LM75B

Esta pantalla contiene el sensor de temperatura LM75B. Este sensor tiene un bus I2C para la lectura de datos desde el microcontrolador. Dicho bus I2C es accesible desde los conectores de pines descritos en la sección inmediatamente anterior.

Figura 2-3 Esquema del sensor LM75B incluido en el módulo del EPD [7]

Es necesario conocer la temperatura para establecer el modo de proceder a la hora de actualizar la pantalla. La forma de actualizar la pantalla variará en función de la temperatura ambiente.

Características:

Las siguientes características son aportadas por el datasheet del componente [6]:

• Bus I2C compatible con hasta 8 dispositivos en el mismo bus. • Rango de suministro de potencia desde 2.8 hasta 5.5 V. • Rango de temperatura desde -50°C hasta 125°C • 11-bit ADC que ofrece una precisión de temperatura de 0.125°C • Precisión de temperatura:

• ±2°C desde -25 °C a +100 °C • ±3°C desde -55 °C a +125 °C

• Puntos de temperatura límite y de histéresis programables. • Rango de corriente de 1.0 µA en modo reposo para ahorrar energía.

Para el objeto de estudio de este proyecto, nos vamos a centrar en el procedimiento a seguir para leer la temperatura medida. Para leer dicha temperatura, son necesarios dos pasos: mandar el byte de configuración que ponga en común las bases del bus I2C mediante el cual se va a realizar la comunicación, y leer el dato del registro temperatura del dispositivo. Los siguientes diagramas muestran el protocolo a seguir en cada paso:

Figura 2-4 Escribir registro de configuración [6]

17

En nuestro caso, el byte de configuración es el de por defecto, es decir, 0x00. Una vez enviado este byte de configuración, se procede a la lectura del registro que sea de interés. En nuestro caso, el registro temperatura.

Figura 2-5 Leer registro Temp, Tos o Thyst incluyendo pointer byte (2-byte data) [6]

Donde:

• Device address: Los tres bits menos significativos (A2, A1 y A0) contienen la dirección de esclavo del sensor.

• El bit write valdrá 1 para escribir y 0 para leer. • Pointer byte: los dos bits menos significativos (P1 y P0) representan el registro que vamos a

leer, en nuestro caso, temperatura (Temp). Los registros posibles son:

Registro P1 P0 R/W Conf 0 1 R/W Temp 0 0 R Tos 1 1 R/W Thyst 1 0 R/W

• De los dos bytes recibidos del dispositivo, solo los 11 más significativos representan la temperatura medida por éste.

La estructura de los bytes recibidos es la siguiente:

MSByte LSByte 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

D10 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 X X X X X

La forma de tener la temperatura en grados centígrados a partir de este Temp Data es:

1. Si D10=0, entonces la temperatura es positiva y su valor es:

(°C) = + (Temp Data) x 0.125°C

2. Si D10=1, entonces la temperatura es negativa y su valor es:

(°C) = -(complemento a 2 de Temp Data) x 0.125°C

18

En el apartado 3.1.1 (I2C) se explicarán las funciones que implementan la comunicación I2C necesaria para la comunicación con este sensor, así como la conversión de los bytes leídos en temperatura.

2.3 Comunicación entre display y microcontrolador

En este apartado se tratarán los pasos a seguir para comunicarse con la pantalla desde el microcontrolador. Para ello, se mostrarán una serie de diagramas de flujos proporcionados por el fabricante del display.

En primer lugar, a continuación, se muestra el diagrama de flujo general a seguir para actualizar el EPD. En apartados posteriores se describirá con más detalle cada sección de este diagrama.

Sección 2: En este apartado se explicará el formato que debe tener el dato imagen, así como las dimensiones de memoria que será necesario tener disponible.

Sección 3: En esta sección se explican los pasos a seguir para encender la pantalla. COG son las siglas de Chip On Glass. G2 representa la versión del chip de la pantalla con el que se trabaja en este proyecto.

Sección 4: Redacta el protocolo de inicialización de pantalla, comprobando los posibles errores que pueden ir sucediendo durante este proceso.

Sección 5: Indica el correcto procedimiento que se debe llevar no solo para cargar una imagen en pantalla, sino para que esta imagen tenga unas buenas características gráficas.

Sección 6: Por último, en esta sección se trata el protocolo a seguir para el correcto apagado del COG driver. Dejando de esta manera desactivada la pantalla, será necesario volver al principio de este diagrama para encender e inicializar antes de dibujar una nueva imagen.

También se puede alternar entre varias imágenes sin necesidad de apagar y reencender/reinicializar la pantalla. De esta manera, la apagaremos cuando realmente hayamos acabado de utilizarla.

Figura 2-6 Diagrama global de actualización del EPD [3]

19

2.3.1 Formato del bus SPI

El bus SPI es utilizado para comunicarse entre el microcontrolador y el G2 COG Driver. Por lo tanto, antes de entrar en más detalle en las secciones indicadas en el diagrama de flujo anterior, es necesario esclarecer las particularidades del formato de las transmisiones SPI que presenta este dispositivo.

En primer lugar, cabe tener en cuenta que la máxima velocidad de reloj del SPI para el G2 COG Driver es 20 MHz, y que se utilizará un chip select que estará en Low cuando a través del bus SPI se están mandando/recibiendo datos, y en High en caso contrario.

El formato del SPI utilizado es el siguiente:

SPI(0xI, 0xD1, 0xD2, 0xD3…)

Donde:

• I es el Command Index, cuya longitud es 1 byte. • D1~n son los Command Data, cuyas longitudes pueden variar desde 1 hasta 110 bytes,

dependiendo del Command Index seleccionado.

Es decir, para mandar un dato a la pantalla por el bus SPI, hay que mandar primero un byte índice y después el byte o los bytes de datos que se quieran mandar. A continuación se muestra una tabla que indica la relación entre el tamaño del dato y el valor del byte índice:

Command Index Número de bytes del Command Data

0x01 8 0x02 1 0x03 1 0x04 1 0x05 1 0x07 1 0x08 1 0x09 1 0x0A <110 0x0B 1 0x0F 1

Tabla 2-2 Relación entre el tamaño del dato y el valor del byte índice. [3]

Además, antes de escribir en el bus SPI el byte índice o el dato, será necesario escribir un byte de cabecera. Estos bytes tendrán un valor u otro en función de a quién vayan precediendo. De este modo, la pantalla será capaz de entender si los bytes que estamos escribiendo son datos o índices, así como si lo que se pretende es escribir o leer del bus.

En las secciones siguientes se explica más detalladamente el método de escritura y lectura del bus SPI.

20

2.3.1.1 Escritura en bus SPI (SPI write)

Aquí se muestra el diagrama de flujo para el proceso de escritura SPI. Como se ha comentado en la sección 2.3.1, tanto el Comman Index como el Command Data van precedidos de sus respectivas cabeceras. En el caso de escritura al bus SPI, estas cabeceras toman el valor de 0x70 para preceder al byte índice y 0x72 para preceder al dato. Por otra parte el chip select (/CS) permanece a 0 siempre que se estén transmitiendo datos por el bus y a 1 en caso contrario.

Como observación, nótese la necesidad de la espera de 80 ns entre el fin de la escritura del byte índice y el comienzo de la cabecera del dato. Durante esta espera, el chip select es puesto a uno, ya que nada se está transmitiendo por el bus. De esta manera se evitan posibles lecturas erróneas que pueda provocar algún tipo de ruido.

Esta espera aparece también al principio del diagrama y se impone para garantizar un tiempo mínimo entre transmisiones. Puede ser necesaria para darle tiempo a la pantalla de analizar los bytes recibidos por el bus en el caso de que la velocidad del maestro sea demasiado elevada.

Por ultimo, como se muestra en el diagrama de flujo, si el Command Data es más largo de 1 bytes, se deben meter datos continuamente sin volver a mandar el Command Index y una vez se hayan terminado de mandar todos los bytes que compongan el dato, se pone el chip select a uno.

A continuación se expone un breve ejemplo de proceso de escritura:

Manda dos comandos SPI write seguidos, SPI(0x08, 0x03) y SPI(0x09, 0xA1)

Figura 2-7 Ejemplo de ejecución de dos comandos de escritura en el bus SPI [3]

Figura 2-8 Diagrama del proceso de escritura en el bus SPI [3]

21

2.3.1.2 Le�ura del bus SPI (SPI read)

En este apartado, se muestra el diagrama de flujo para el proceso de lectura del bus SPI. Al igual que en el proceso de escritura descrito en el aprtado anterior (2.3.1.2), tanto el Command Index como el Command Data van precedidos de sus respectivas cabeceras. En este caso, al tratarse de lectura del bus SPI en vez de escritura, el valor de estas cabeceras son 0x70 para preceder al byte índice (al igual que en el proceso de escritura) y 0x73 para preceder a la lectura del dato. Al tomar esta última cabecera el valor de 0x73, se le está indicando a la pantalla no solo que lo que viene a continuación es el dato, sino que lo que se desea es leer del bus.

Por lo demás, este proceso presenta las mismas particularidades que el proceso de escritura descrito en el apartado anterior: chip select a 0 mientras se usa el bus y a 1 en caso contrario y pequeñas esperas entre transmisiones que garanticen tiempo suficiente para procesar los datos recibidos.

Por último, también de forma análoga al proceso de escritura, mientras se recibe el dato se mandan bytes vacíos (0x00) hasta que la lectura haya finalizado, todo ello sin volver a mandar el Command Index.

Siguiendo la estructura seguida en el apartado anterior, a continuación se muestra un simple ejemplo del proceso de lectura con la finalidad de esclarecer este proceso:

Manda un comando SPI read : SPI_R(0x0F, 0x00)

Figura 2-9 Ejemplo de lectura del bus SPI [3]

Figura 2-10 Diagrama del proceso de lectura del bus SPI [3]

22

2.3.1.3 SPI read COG ID

En este apartado se trata el caso particular en el que el objeto de la lectura es el COG ID. Este caso es de interés puesto que es necesario ejecutar este comando durante el proceso de inicialización del COG driver, que será ejecutado cada vez que se encienda la pantalla.

Al igual que en los dos casos anteriores, se muestra el diagrama de flujo del proceso. En dicho diagrama también se muestra la espera que garantiza el tiempo necesario entre transmisiones que permita el procesado de estas, así como la puesta a 0 del chip select en caso de que se esté usando el bus o a 1 en caso contrario.

El proceso de lectura es idéntico al descrito en el comando de lectura, puesto que no es más que un caso particular de este, en el sentido de que se mandan bytes vacíos hasta que se recibe el byte que se desea leer (COG ID).

La particularidad que presenta este caso es que no es necesario mandar Command Index y que además la cabecera que precede al dato es 0x71. La ausencia del Command Index se justifica con la propia definición de este byte. El Command Index se utiliza para anunciar el tamaño del dato, pero en este caso el dato que se va a leer es el COG ID, de tamaño conocido 1 byte. De esta manera, al mandar la cabecera 0x71, la pantalla ya entiende que esta cabecera precede a un dato que el maestro quiere leer del bus y que ese dato es el COG ID.

Figura 2-11 Diagrama de flujo para la lectura del COG ID [3]

23

2.3.2 Escribir en memoria

En este apartado se trata el primer bloque del algoritmo global de actualización del EPD mostrado en el apartado 2.3, correspondiendo este apartado a la sección 2.

Antes de pasar a los apartados de encender e inicializar la pantalla, en esta sección se trata brevemente la estructura que debe tener el dato de imagen que después se representará en pantalla.

La imagen no es más que un vector de uint8_t en el que cada byte almacena el valor de 8 pixeles (blanco/negro). Las funciones que se describirán más adelante se encargarán de diferenciar cada línea y columna de esta imagen y de representarla en la pantalla.

Por último, aclarar que, al ser la resolución de la pantalla 264 x 176 pixeles, el tamaño de la imagen será de 5.808 bytes (33bytes por línea x 176 líneas). A la hora de mandar la imagen a la pantalla es necesario tener esa memoria disponible en la memoria RAM o, en su defecto, usar memoria Flash. En el caso que ocupa a este proyecto, el microcontrolador que se va a utilizar es el MSP432P401R Launchpad, el cual dispone de 64 KB de memoria RAM, por lo cual se podrá albergar sin problema este buffer de imagen en la memoria RAM. En el apartado 3 se expondrán más detalles sobre el MSP432P401R Launchpad.

24

2.3.3 Encendido del G2 COG driver- Encendido de pantalla

En esta sección se explicará el segundo bloque (sección 3) del diagrama de flujo presentado en el apartado 3. Es decir, se tratan los pasos a seguir para encender correctamente la pantalla. A continuación se muestra el diagrama de flujo que contiene dichos pasos:

En primer lugar, cabe destacar el estado inicial de las variables. Estos valores iniciales son:

VCC/VDD=0, /Reset, /CS, /BORDER_CONTROL*2, /SI, /SCLK =0

Es de interés conocer estos valores para inicializar los pines del microcontrolador que se definan para manejar estas señales.

Una vez que la pantalla esté alimentada con una tensión de entre 2.3 y 3.6V, se actualizan los parámetros /CS, BORDER_CONTROL y /RESET a 1.

A continuación, tras una espera de 5 ms, se alterna /RESET=0 y /RESET=1 con otra espera intermedia de 5 ms.

Por último, se vuelve a realizar una espera de 5 ms y con esto finaliza el encendido de la pantalla. En este punto se puede pasar a la inicialización de la misma cuando lo desee el usuario.

En el apartado 2.2 Conexiones, se indica a que pines del micro corresponden estas señales (/CS, /RESET y /BORDER_CONTROL) siendo /CS el chip select del SPI.

Además de lo aquí indicado, se aprovechará este punto para inicializar el SPI. Esto no es más que establecer las condiciones y parámetros necesario para fijar y definir perfectamente el bus SPI. Es necesario inicializarlo en este punto porque en la sección siguiente (inicializado del G2 COG driver) es necesario leer y escribir en el bus SPI. Se explicará con más detalle este proceso de inicialización en el apartado 3 Librerías y funciones, concretamente en la sección 3.1.2 SPI.

Figura 2-12 Diagrama de flujo de encendido del G2 COG driver [3]

25

2.3.4 Inicialización del G2 COG driver

En esta sección se explicará el tercer bloque (sección 4) del diagrama de flujo presentado en el apartado 3. Es decir, se tratan los pasos a seguir para la correcta inicialización de la pantalla.

El primer paso consiste en esperar a que el COG driver esté preparado para inicializarse. Esto se comprueba con la variable busy, pin P3.2 del micro si se sigue la misma conexión que en este proyecto, la que se indica en el apartado 2.1 Conexiones. Una vez la pantalla esté lista devolverá un 0 a este pin y entonces se pasará al siguiente paso.

En primer lugar, se lee el COG ID, el cual debe valer 0x12 para la pantalla de 2.7’’ [3]. En el caso de que el valor leído sea 0x12 significará que todo va bien y que podemos continuar. En caso contrario, ha ocurrido algún error y habrá que reiniciar el proceso y analizar el origen del error.

A continuación, se deshabilita el panel, mediante un comando de escritura SPI con Command Index 0x02 y Command Data 0x40 (apartado 2.3.1), y se comprueba si este está roto. Esta comprobación se realiza con un comando de lectura del bus SPI con Command Index 0x0F (apartado 2.3.1). Si el valor que se lee del bus en este punto es 0x80 [3], significa que todo va bien y que el panel no está roto, en caso contrario se ha detectado una ruptura en el panel y el código que implemente la inicialización del COG driver deberá devolver una señal de error que avise sobre este problema.

Con la comprobación de ruptura realizada, se activa el modo de ahorro de energía, mediante un comando de escritura SPI con el Command Index 0x0B y el Command Data 0x02 (apartado 2.3.1), y ya se procede a la selección del canal mediante otro comando escritura con Command Index 0x01 (apartado2.3.1) y dato dependiendo del tamaño de la pantalla. En el caso de la pantalla de 2.7’’ esta dato toma el valor Data=(0x0000, 007F, FFFE, 0000) [3].

Una vez seleccionado el canal, se pasa a configurar una serie de ajustes de potencias y tensión y ya se llega al bucle final. En este bucle se activa el multiplicador de tensión positiva mediante un comando de escritura de Command Index 0x05 y un Command Data de 0x01 (apartado2.3.1), se realiza una espera de 150 ms y se activa el multiplicador de tensión negativa de la misma manera que el de tensión positiva pero cambiando el Command Data por 0x03 (apartado 2.3.1). Después, tras realizar una espera de al menos 90 ms, se impone el multiplicador de tensión en Vcom y se verifica el estado del DC/DC tras realizar una espera de al menos 40 ms. Si de esta comprobación se recibe el valor 0x40, se sale del bucle y se notifica que la inicialización ha finalizado. En caso contrario, se repite el bucle hasta un total de 4 veces. Si en ninguna de estas repeticiones se consigue comprobar DC/DC con éxito habrá que reiniciar el proceso y analizar el origen del posible error.

Una vez finalizado el proceso de inicialización, ya se puede representar la imagen en pantalla (sección 2.3.5 Escribir datos de la memoria al EPD)

Este proceso de inicialización, junto al proceso de encendido, se implementarán en una función denominada EPD_ON, la cual se explica en el apartado 3. Librerías y funciones. Además puede verse el código de dicha función en el anexo.

A continuación se muestra el diagrama de flujo que expone los pasos a seguir para la inicialización del G2 COG driver.

26

Figura 2-13 Diagrama de flujo de la inicialización del G2 COG driver. [3]

27

2.3.5 Escribir dato de la memoria al EPD

En esta sección se explicará el cuarto bloque (sección 5) del diagrama de flujo presentado en el apartado 3. Es decir, describe cómo deben ser mandados los datos al G2 COG driver, que actualizará el display.

El G2 COG driver usa un buffer para almacenar una línea de datos y después escribirla en el display. Por lo tanto, se deberán enviar los datos línea por línea.

De este modo, en las siguientes subsecciones se tratará la forma de transmitir la línea de datos al buffer del G2 COG driver, los diferentes métodos para recorrer todas las líneas de la pantalla y el flujo global de actualización de imagen en pantalla.

28

2.3.5.1 Almacenar una línea de dato en el buffer

Esta sección describe los detalles de cómo mandar datos al G2 COG driver. Como se ha mencionado anteriormente, el G2 COG driver usa un buffer para actualizar el display línea por línea. En este diagrama de flujo se observa la forma de mandarle una línea de datos: bytes impares, bytes de escaneo y bytes pares.

El diagrama recorre las 176 líneas de la pantalla y manda los datos correspondientes a cada una de ellas una a una. A continuación veremos la forma de mandar la línea de datos en cuestión:

• En primer lugar, píxeles impares • En segundo lugar, Scan Bytes o bytes de

escaneos. Cada dos bits de escaneo representan una línea. Si estos bits están a 1, esta línea estará en modo Scan on, por lo contrario, si valen 0 estará en modo Scan off. Solo una línea estará en modo Scan on, mientras las demás estarán todas en modo Scan off. La línea que este en modo Scan on será en la que se represente esta línea de datos que se está enviando.

• Por último, se completa la línea de datos con los píxeles pares.

Una vez mandada toda la línea de dato, se sacan los datos hacia el panel mediante el comando de escritura en bus SPI que se muestra en el diagrama. Así finalizaría la escritura de una línea de datos en pantalla.

Esta forma de escribir una línea de dato se implementa en la función line explicada en el apartado 3 Librerías y funciones. Además, puede consultarse el código de dicha función en el anexo.

Figura 2-14 Diagrama de flujo de recorrido de pantalla especificando estructura de los datos de línea [3]

29

2.3.5.2 Recorrer el display

Una vez conocida la forma de mandar una línea de datos al buffer del G2 COG driver, en este apartado trataremos los distintos métodos de recorrer la pantalla: Block type y Frame type. Ambos métodos serán implementados y usados en el ciclo global de actualización de pantalla.

• Frame type

Figura 2-15 Método Frame Type de recorrido la pantalla [3]

Este método consiste básicamente en recorrer la pantalla desde la primera línea hasta la última actualizando una vez cada línea. A la derecha se muestra el diagrama de flujo:

Se manda una línea de dato como se ha explicado en el apartado anterior y se envía al panel mediante el comando SPI indicado en el diagrama. Se repite el proceso para cada línea hasta completar todas las líneas.

Para que la imagen quede bien representada, este proceso de recorrido de pantalla debe ser repetido durante un tiempo que será fijado en función de la temperatura ambiente y la experiencia. En caso contrario, la pantalla no se polarizará correctamente y la imagen representada no tendrá la calidad gráfica necesaria. Además, puede que no se sobrescriba bien la imagen anterior, quedando ésta en modo imagen fantasma en el fondo de la pantalla.

Por último, aclarar que la variable Scan Line del diagrama de flujo representa el número de líneas de la pantalla, en este caso 176.

Este método está implementado en la función frame_time_13, la cual se explicará en el apartado 3 Librerías y funciones. Además su código se puede consultar en el anexo.

Figura 2-16 Diagrama de flujo del método “Frame Type” de recorrido de pantalla [3]

30

• Block type

Este método desplaza un bloque de líneas por el EPD. Reduce el tiempo de refresco o de recarga de la línea ya que agrupa las líneas por bloques, a diferencia del método anterior (Frame Type), que tiene que recorrer toda la pantalla antes de volver a refrescar la misma línea. Este método por bloques consiste en mover un bloque o conjunto de líneas (block) un número determinado de líneas (step) hasta terminar de recorrer la pantalla (primera repetición).

De este modo, se va “repintando” mismas zonas con cada actualización del bloque.

Para este tipo de escaneo es necesario definir tres variables:

Block (bloque):

Block es una agrupación de líneas del EPD. Puede condicionar el tiempo de refresco/recarga de línea. Un bloque pequeño hace que este tiempo sea menor, mientras que un bloque mayor ralentizaría este tiempo. Por último, la variable Block debe ser divisible por el parámetro Step.

Step (salto):

Step representa el número de líneas que debe ser desplazado Block. Decide cuantas veces será escaneada cada línea. Un Step menor consigue mayor número de escaneo, mientras que, por lo contrario, un Step mayor haría que cada línea se escaneara menos veces. El número total de líneas debe ser divisible por la variable Step.

Repeat Number (número de repeticiones):

Es el número de veces que se recorre la pantalla completa. Es decir, una vez que el bloque haya recorrido la pantalla completa, volverá a repetir el proceso este número de veces.

Figura 2-17 Método “Block Type” de recorrido de pantalla [3]

31

A continuación, se muestra el diagrama de flujo de este método de bloques:

En este diagrama, la variable X contiene el número de veces que hay que recorrer la pantalla (Repeat number), la variable Y el número de veces que se ha desplazado el bloque y Z la línea del display por la que va el algoritmo.

De este modo, lo primero que nos preguntamos es si la línea en la que nos encontramos (valor de la variable Z) está dentro del bloque en el que nos encontramos actualmente. Esta línea pertenecerá al bloque si su valor está entre (Y) x (tamaño del bloque) y (Y+1) x (tamaño del bloque).

En caso de que pertenezca, se mandara la línea de dato al buffer del COG driver y se sacará a pantalla. Después se aumentará la variable Z, que representa la línea por la que vamos, hasta llegar al final de la pantalla o una línea que no pertenezca al bloque en el que nos encontremos. En ambos casos, se pasa a incrementar la variable Y, y en caso de no haber superado la Y máxima, se vuelve a repetir el bucle anterior.

Por último, una vez que Y ha superado el último bloque de la pantalla, si X aún no es igual al número de repeticiones, se vuelve a inicializar las variables Y y Z y se repite el proceso anterior. Cuando se hayan realizado todas las repeticiones, la representación de esta imagen ha finalizado.

Este método está implementado en la función frame_data_13, la cual se explicará en el apartado 3 Librerías y funciones. Además su código se puede consultar en el anexo.

En el siguiente apartado se indicará en que ámbitos del ciclo de actualización de pantalla se utiliza cada uno de estos dos métodos.

Notas:

𝑆𝑆ℎ𝑖𝑖𝑖𝑖𝑖𝑖 =𝑇𝑇𝑇𝑇𝑖𝑖𝑇𝑇𝑇𝑇 𝑇𝑇𝑖𝑖𝑙𝑙𝑙𝑙 + (𝐵𝐵𝑇𝑇𝑇𝑇𝐵𝐵𝐵𝐵 − 𝑆𝑆𝑖𝑖𝑙𝑙𝑆𝑆)

𝑆𝑆𝑖𝑖𝑙𝑙𝑆𝑆

Figura 2-18 Diagrama de flujo del método “ Block Type” de recorrido de pantalla [3]

32

2.3.5.3 Flujo global de a�ualización

En este apartado se explica el método general que se debe seguir para cargar una imagen en pantalla. Es importante seguir los pasos que se van a describir a continuación para poder conseguir una buena calidad gráfica de la imagen evitando así el efecto de imágenes fantasmas.

En primer lugar, hay que diferenciar entre dos rangos de temperatura:

• Para temperatura ambiente comprendida entre 0 y 50 °C

Figura 2-19Flujo global de actualización para temperaturas comprendidas entre 0 y 50 °C [3]

Fase 1: se muestra el negativo de la nueva imagen. Fase 2: se alterna pantallas en blanco y en negro para limpiar la imagen previa. Tanto el número de veces que se alternan las pantallas como el tiempo que permanecen dibujadas, son parámetros que se fijarán en función de la temperatura ambiente y la experimentación. Fase 3: nueva imagen. Si el nivel de imagen fantasma es inaceptable se puede incrementar el tiempo de cada pantalla blanco/negro del paso 2.

• Para bajas temperaturas, comprendidas entra -20 y 0 °C

Figura 2-20 Flujo global de actualización para temperatura comprendidas entre -20 y 0 °C [3]

Para este rango de temperaturas es altamente recomendable repetir el ciclo de actualización de imagen cada 6 horas para garantizar un buen nivel de rendimiento óptico y reducción de imágenes fantasmas. Este esquema se muestra solo a título ilustrativo, ya que el rango de trabajo de este proyecto es el anterior, temperaturas entre 0 y 50 °C.

A continuación se detallarán las distintas fases del flujo global de actualización de pantalla para temperaturas comprendidas entre 0 y 50 °C.

33

Fase 1 (stage 1): Inversa de la nueva imagen

Durante esta fase se muestre el negativo de la nueva imagen que se desea representar en pantalla utilizando el método de bloques. Para representar la imagen inversa basta con invertir los valores del vector imagen inmediatamente antes de mandarlos al COG driver.

Fase 2 (stage 2): Blanco y negro

Durante esta fase se alternan pantallas blancas y negras un determinado número de veces. Etas pantallas blancas y negras se actualizan con el método “Frame Type”.

Cada pantalla negra se volverá a pintar hasta que haya pasado un tiempo denominado Stage Time. Una vez transcurrido este tiempo, se pintará una pantalla blanca y se volverá a pintar hasta que, de nuevo, se agote este tiempo. Este proceso se repetirá el númro de veces que se considere necesario, en el caso de este proyecto 2 veces.

Fase 3 (stage 3): Nueva imagen

Por último, durante esta última fase, se representa la imagen final mediante el diagrama de bloques. Cumpliendo este ciclo global de actualización, la nueva imagen debería quedar representada perfectamente. Si aún asi, la pantalla presenta restos fantasmas de imagen anterior, se puede aumenter el tiempo que permanecen las pantallas blancas y negras (Stage Time) y el número de veces que se alternan estas pantallas.

Figura 2-21 Diagrama de flujo de la fase dos del diagrama global de actualización [3]

34

2.3.6 Apagar el G2 COG driver

En esta sección se explicará el quinto bloque (sección 6) del diagrama de flujo presentado en el apartado 3. Es decir, el apagado de la pantalla.

Es necesario apagando la pantalla de forma segura, siguiendo los pasos que te indica el fabricante. De esta manera se garantiza la conservación de la imagen con mejor calidad. Para pintar otra imagen nueva en pantalla, será necesario volver a repetir los procesos de encendido e inicialización del G2 COG driver.

Esta función está implementado en la función EPD_off, la cual se explicará en el apartado 3 Librerías y funciones. Además su código se puede consultar en el anexo.

2.3.7 Resumen final

A lo largo del apartado 2 hemos analizado como se controla la pantalla, el método de comunicación tanto con la pantalla en si como con el sensor de temperatura. Como se ha mencionado a lo largo de las diferentes subsecciones, todas estas funciones se han implementados y se explicarán en el apartado 3. Librerías y funciones. Además, se puede consultar el código de cada una de ellas en el anexo.

35

3 LIBRERÍAS Y FUNCIONES

En este apartado se explicarán las funciones y librerías desarrolladas para el acercamiento de la pantalla al usuario. Dichas funciones y librerías son divididas en tres grupos: librerías básicas, librería de actualización de EPD y librería gráfica.

El microcontrolador utilizado es el MSP432P401R con el sistema de desarrollo MSP-EXP432P401R de Texas Instruments, del cual se enumera a continuación brevemente algunas de sus características básicas [1]:

• 48MHz • 32-bit ARM Cortex M4F with Floating Point Unit and DSP acceleration • 256KB Flash • 64KB RAM • 24ch 12-bit ADC • Comparator • 16-bit, and 2 32-bit Timers • Up to 4 I2C, 8 SPI, 4 UART

Este micro tiene memoria RAM suficiente para almacenar la imagen que se desea pasar a pantalla por lo que no es necesario utilizar la memoria flash para esta función.

A continuación, se muestra una imagen de la placa MSP432P401R Launchpad:

Imagen 3-1 MSP432P401R Launchpad board, Texas Instruments.

En esta imagen se observan los distintos pines y puertos accesibles desde la placa, así como pulsadores disponibles y leds incrustados.

Además, con el objetico de distribuir los pines de conexiones con la pantalla, en la siguiente imagen se muestra las funciones que pueden desempeñar cada pin del Launchpad.

36

Imagen 3-2 Portmap del MSP432P401R Launchpad

Ahora sí, se pasa a explicar las diferentes funciones desarrolladas para el control de la pantalla de tinta electrónica desde este micro. Tal y como se ha mencionado anteriormente, dichas funciones están organizadas en librerías, habiendo 3 librerías principales: Librerías básicas, Librería de actualización de pantalla y librería gráfica.

Imagen 3-3 MSP432P401R Launchpad, Texas Instruments, y 2.7’’ e-paper display, Embedded Artists, conectados.

37

3.1 Librerías básicas

En este grupo de librerías básicas se incluyen las librerías encargadas de controlar los estándares I2C y SPI garantizando la compatibilidad con las particularidades descritas por el fabricante del EPD.

3.1.1 I2C

El I2C es un bus serie de datos que se utiliza principalmente para la comunicación entre las diferentes partes de un circuito. Está diseñado como un bus maestro-esclavo. La transferencia de datos es siempre inicializada por el maestro y entonces el esclavo reacciona.

El inicio de una transmisión es indicado por la señal de inicio del maestro, seguido de la dirección. Ésta es confirmada por el ACK-Bit del esclavo correspondiente. En función del R/W-Bit se escriben bytes de datos (datos al esclavo) o se leen (datos al maestro). El ACK es enviado desde el esclavo al escribir, y desde el maestro al leer. El último byte “leído” es reconocido por el maestro como un NACK (not acknowledge), para indicar el final de una transmisión. Una transmisión es finalizada por la señal de parada. Como alternativa, puede ser enviada una señal de reset al arranque de una nueva transmisión, sin necesidad de parar la transmisión anterior con una señal de parada.

En este caso en particular, la librería I2C es utilizada para leer la temperatura del sensor LM75B incluido en la pantalla.

En esta librería básicamente se han desarrollado tres funciones: inicialización de I2C, escritura y lectura.

void initI2C(void); bool writeI2C(uint8_t ui8Addr, uint8_t ui8Reg, uint8_t *Data, uint8_t ui8ByteCount); bool readI2C(uint8_t ui8Addr, uint8_t ui8Reg, uint8_t *Data,

uint8_t ui8ByteCount);

InitI2C:

Sin argumentos de entrada ni salida, establece el periférico que se utilizará para la comunicación I2C, así como los parámetros necesarios para describir esta comunicación.

WriteI2C

Esta es la función que se encargará de escribir/mandar dato desde el microcontrolador hasta el sensor LM75B.

Tiene como argumento de salida una variable booleana que devolverá true si la transmisión se ha completado correctamente o false en caso contrario.

Los argumentos de entradas son:

38

• uint8_t ui8Addr: la dirección del periférico con el que se pretende establecer la comunicación (LM75B en este caso).

• uint8_t ui8Reg: el registro. • uint8_t *Data: puntero al dato que se desea transmitir. • uint8_t ui8ByteCount: longitud en bytes de este dato.

ReadI2C

Esta es la función que se encargará de leer/recibir dato del sensor LM75B.

Los argumentos de salida y entrada son idénticos a los de la función WriteI2C salvo que, en este caso, el puntero *Data apunta al vector o variable donde se almacenará el dato recibido.

Con estas tres funciones ya definidas, los comandos necesarios para recibir la temperatura del LM75B son los siguientes:

initI2C(); /* write configuration register I2C */ writeI2C(addr,0x01,conf,1); /* Leo temperatura */ readI2C(addr,0x00,pRXTemp,2);

Donde:

• addr es la dirección del periférico: 0x49 • conf es el puntero que apunta al dato: 0x00 en este caso. • pRXTemp es el puntero que apunta al vector de dos variables donde se almacenarán los dos

bytes recibidos del sensor.

De los dos bytes recibidos, solo los 11 bits más significativos representan la temperatura. La temperatura queda almacenada en una variable denominada Temperatura que más adelante se utilizará para seleccionar parámetros de tiempos, block, step y repeat number descritos en apartados anteriores.

3.1.2 SPI

El Bus SPI (Serial Peripheral Interface) es un estándar de comunicaciones, usado principalmente para la transferencia de información entre circuitos integrados en equipos electrónicos. Incluye una línea de reloj, dato entrante, dato saliente y un pin de chip select, que conecta o desconecta la operación del dispositivo con el que desea comunicarse.

El SPI es un protocolo síncrono. La sincronización y la transmisión de datos se realiza por medio de 4 señales:

• SCLK (Clock): Es el pulso que marca la sincronización. Con cada pulso de este reloj, se lee o se envía un bit.

• MOSI (Master Output Slave Input): Salida de datos del Master y entrada de datos al Slave. También llamada SIMO.

• MISO (Master Input Slave Output): Salida de datos del Slave y entrada al Master. También conocida por SOMI.

https://es.wikipedia.org/wiki/Reloj

39

• SS/Select: Para seleccionar un Slave, o para que el Master le diga al Slave que se active. También llamada SSTE.

En nuestro caso usaremos este Bus para comunicarnos con un solo esclavo (la EPD) desde un solo maestro (msp432). Como se ha descrito en apartados anteriores, se necesita SPI para comunicarse con la pantalla y poder tanto inicializar el G2 COG driver como mandar los datos de la imagen que se pretenda representar en ella.

En esta librería se han desarrollado cuatro funciones: inicialización del SPI, escritura, lectura y apagado del SPI.

void initSPI(void); void SPI_off(void); void SPI_send( const uint8_t *buffer, uint16_t length); uint8_t SPI_read(const uint8_t *buffer,uint16_t length);

InitSPI:

Sin argumentos de entrada ni salida, establece el periférico que se utilizará para la comunicación SPI, así como los parámetros necesarios para describir esta comunicación. En este caso, establece un reloj para el SPI de 12 MHz y configura e inicializa el pin que se utilizará como chip select.

SPI_send:

Esta es la función que se encargará de mandar datos al bus SPI.

Los argumentos de entrada son:

• const uint8_t *buffer: puntero al vector que almacena los datos que se desean enviar.

• uint16_t length: longitud del vector anterior, es decir, número de bytes que se pretendan enviar.

SPI_read:

Es la función encargada de recibir los datos que sean mandados por el EPD.

Al igual que la función SPI_send, los argumentos de entrada son: un puntero que apunta al vector que almacena los datos a mandar, y la longitud de este vector. En este caso los datos a mandar son los registros necesarios para establecer la comunicación y empezar a recibir datos.

El argumento de salida es el dato recibido vía esta comunicación SPI.

SPI_off:

De forma análoga a InitSPI, esta función sin argumentos de entrada ni salida se encarga de apagar el canal SPI y las interrupciones asociadas.

40

3.2 Librería de actualización de pantalla

Esta librería contiene las funciones responsables de actualizar la pantalla. El objetivo final de estas funciones es: limpiar pantalla y representar una imagen en pantalla. También se incluyen las funciones de encender y apargar el EPD.

Básicamente, las funciones incluidas en esta librería son la implementación de los diagramas de flujos representados en el apartado 2.4.

Estas funciones están basadas en el proyecto para arduino “E-Inck for Arduino”, concretamente en la librería EPD2 [8].

En primer lugar, se analizarán las funciones de más bajo nivel:

void line (uint16_t line, const uint8_t *adata, uint8_t fixed_value, EPD_stage stage, uint8_t border_byte); void frame_fixed_timed(uint8_t fixed_value, long stage_time); void frame_fixed_13(uint8_t value, EPD_stage stage); void frame_data_13(const uint8_t *image, EPD_stage stage); void frame_stage2();

line:

Como se ha mencionado anteriormente, el EPD hay que actualizarlo línea por línea. Esta es la función que actualiza una línea de la pantalla. Esta actualización se puede realizar bien cargando una línea de una imagen almacenada en memoria, o bien con un valor de byte predefinido en los argumentos de entrada.

Los argumentos de entradas son:

• uint16_t line: línea que se va a actualizar. En el caso de la pantalla con la que se trabaja en este proyecto, esta variable puede ir desde 1 hasta 176.

• uint8_t *adata: este puntero debe apuntar a la línea de la imagen que se desea representar en pantalla. Esta imagen tiene que estar almacenada en un vector tipo uint8_t.

Si lo que se pretende no es cargar una línea de una imagen sino un valor predefinido, esta variable tomará el valor de 0.

• uint8_t fixed_value: es el valor predeterminado que se le asignara a cada byte de la línea en caso de que, como se ha mencionado anteriormente, el argumento *adata esté vacío.

• EPD_stage stage: en primer lugar, es necesario definir el tipo EPD_stage:

typedef enum { // Image pixel -> Display pixel EPD_inverse, // B -> W, W -> B (New Image) EPD_normal // B -> B, W -> W (New Image) } EPD_stage;

Esta variable simplemente puede tomar dos valores: EPD_inverse o EPD_normal. En el primer caso invierte el valor del pixel de negro a blanco o viceversa y en el segundo deja el pixel tal y como esté.

41

Esto es de utilidad cuando, como se ha explicado en apartados anteriores, es necesario representar el negativo de la imagen durante el proceso de representación de imagen en pantalla.

• uint8_t border_byte: por último, el valor del border_byte, que será enviado al comienzo de la ejecución de la función. Esta variable puede tomar tres valores diferentes: 0xff (BORDER_BYTE_BLACK), 0xaa (BORDER_BYTE_WHITE) y 0x00 (BORDER_BYTE_NULL).

frame_fixed_timed:

Esta función refresca una imagen simple en la pantalla (pantalla en negro o pantalla en blanco) y la mantiene un tiempo si es necesario. Forma parte de una función superior (frame_stage2) que se describirá más adelante.


• uint8_t fixed_value: es el valor predeterminado que tomará la pantalla. Puede tomar los valores “0xff” para que la pantalla sea negra o “0xaa” para que sea blanca.

• long stage_time: este argumento representa el tiempo que deberá ser mantenida la imagen en caso de que sea necesario. Este tiempo dependerá de la temperatura previamente medida del sensor LM75B. Con esta temperatura como argumento de entrada, se accede a la función set_factor. Esta función modifica una variable global en la que almacena, a parte de estos valores de tiempos, valores de las variables block, step y repeat, definidos en apartados anteriores y necesarios para el recorrido y actualización de la pantalla.

void setFactor(int temperatura);

En función de la temperatura leída por el sensor LM75B, esta función selecciona el valor de las variables mencionadas. Hay tres grupos de valores, según la temperatura esté entre 0 y 10°C, 10 y 40°C o 40 y 50°C.

Obsérvese que, básicamente, esta función representa el método de recorrido de pantalla Frame Type descrito en el apartado 2.3.5.4 (Frame Type).

frame_fixed_13:

Esta función recorre toda la pantalla con el método de bloques definido en el apartado 2.3.5.4 (Block type) dibujando la pantalla de un valor predeterminado (blanco o negro).


• uint8_t value: el valor del que se dibujara la pantalla completa (0xff para negro o 0xaa para blanco).

• EPD_stage stage: en este caso, este argumento se utiliza simplemente para diferenciar la fase 1 y 3 del método de bloques (apartado 2.3.5.4(Block Type)). De este modo, si stage=EPD_inverse, se considerará en la fase 1 y si, en caso contrario, stage=EPD_normal, se considerará en la fase 3.

Es necesario conocer la fase en el que se encuentra la ejecución del código para seleccionar las variables fijadas por la función set_factor.

42

frame_data_13:

Igual que la función anterior, esta función recorre toda la pantalla con el método de bloques dibujando, en este caso, una imagen almacenada en memoria.


• const uint8_t *image: es el puntero que apunta al vector imagen el cual almacena la imagen que se desea representar en la pantalla. Este vector debe ser tipo uint8_t y tamaño 5808 (176 líneas x 33 bytes por línea).

• EPD_stage stage: este argumento deberá tomar valor EPD_inverse para dibujar la imagen en negativo (sustituir el blanco por el negro y el negro por el blanco) o EPD_normal para dibujarla tal cual. Esto es necesario porque como se describió en el apartado 2.3.5.2 Flujo global de actualización, en el proceso de actualización de pantalla es necesario dibujarla primero en negativo.

frame_stage2:

Esta función implementa la segunda fase del flujo global de actualización (descrito en el apartado 2.3.5.2), es decir, alterna pantallas blancas y negras para limpiar la imagen previa un número determinado de veces fijado por la función set_factor. Esta función contiene a la función frame_fixed_time.

void frame_stage2() { uint16_t i; for ( i = 0; i < compensation.stage2_repeat; ++i) { frame_fixed_timed(0xff, compensation.stage2_t1); frame_fixed_timed(0xaa, compensation.stage2_t2); } }

En segundo lugar, a continuación, se mencionan las funciones encargadas del encendido y apagado del G2 COG driver:

EPD_error EPD_ON (void); void EPD_off(void);

EPD_ON:

Siguiendo los diagramas de flujo de los apartados 2.3.3 y 2.3.4, esta función se encarga de encender e inicializar el G2 COG driver.

No tiene ningún argumento de entrada, pero si un argumento de salida tipo EPD_error. Según el valor que devuelva la función al ejecutarse, se podrá conocer si el encendido e inicialización del EPD ha transcurrido satisfactoriamente o si, por lo contrario, ha habido algún error y, en este caso, cual ha sido este error. Así pues, el tipo EPD_error tiene la siguiente estructura:

typedef enum { // error codes EPD_OK, EPD_UNSUPPORTED_COG, EPD_PANEL_BROKEN, EPD_DC_FAILED } EPD_error;

43

EPD_off:

En este caso, sin argumentos de entrada ni salida, en esta función se implementa el apagado seguro explicado en el apartado 2.3.6, encargado de apagar el G2 COG drver.

Por último, faltan por analizar las funciones que son el objetivo de esta librería: limpiar pantalla y representar imagen en pantalla. Estas funciones no son más que combinación de las funciones descritas a lo largo de este mismo apartado.

Limpiar pantalla:

/****** clear********/ frame_fixed_13(0xff, EPD_inverse); frame_stage2(); frame_fixed_13(0xaa, EPD_normal);

El proceso de limpiar pantalla contiene tres fases:

• Poner pantalla completamente en negro mediante el método de bloques (frame_fixed_13(0xff, EPD_inverse);)

• Alternar pantallas blancas y negras representadas mediante el método Frame Type. El número de repeticiones de estas pantallas así como el tiempo que se conservan está fijado por la función set_factor. (frame_stage2();)

• Poner la pantalla en blanco mediante el método de bloques (frame_fixed_13(0xaa, EPD_normal);)

Con esta pantalla en blanco se finaliza el limpiado de pantalla, y el EPD se queda con la pantalla completamente blanca, “limpia” de restos de imágenes representadas anteriormente.

Representar imagen en pantalla:

/****** output an image********/ frame_data_13(imagen, EPD_inverse); frame_stage2(); frame_data_13(imagen, EPD_normal);

En el caso de representar imagen por pantalla, el proceso también tiene tres fases:

• Representar la imagen en negativo mediante el método de bloques (frame_data_13(imagen, EPD_inverse);)

• Alternar pantallas blancas y negras un número determinado de veces, fijado por la función set_factor. Estas pantalla se dibujan mediante el método Frame Type (frame_stage2();)

• Dibujar la nueva imagen en modo normal mediante el método de bloques (frame_data_13(imagen, EPD_normal);)

44

3.3 Librería gráfica

El fin de esta librería es crear la imagen durante la ejecución del código, sin necesidad de tenerla previamente guardada en memoria. Para ello, se han desarrollado funciones que pintan línea horizontal, vertical y rectángulo. Además, con las funciones número y texto se puede acceder a números de una determinada fuente en la primera y a cualquier carácter ASCII imprimible mediante el código ASCII en la segunda, como se explica a continuación. Por último, la función imagen_pequeña permite situar y dibujar una imagen de tamaño inferior al display posibilitando así incluir varias imágenes simultaneas en la pantalla.

Algunas de estas funciones están basadas en las librerías gráficas que te proporciona el módulo MSPWARE de Code Composer Estudio, Texas Instruments.

void linea_horizontal ( uint8_t *imagen, int x_ini, int y_ini, int x_final, int grosor, bool *pintado); void linea_vertical ( uint8_t *imagen, int x_ini, int y_ini, int y_final, int grosor, bool *pintado); void rectangulo ( uint8_t *imagen, int x_ini, int y_ini,int ancho, int alto, int grosor, bool *pintado); void pinta_texto (int *caracteres, int longitud, uint8_t *imagen, int x_ini, int y_ini, bool *pintado); void pinta_numero (int *caracter, int longitud, uint8_t *imagen, int x_ini, int y_ini, bool *pintado); void imagen_pequeña ( uint8_t *imagen, const uint8_t *imagenp, int x_ini, int y_ini,int ancho, int alto, bool *pintado); Todas estas funciones modifican el vector imagen. Este vector es de tipo uint8_t y tamaño 5808 (176 líneas x 33 bytes por línea) y representa la imagen que después será pintada en pantalla.

La variable booleana *pintado apunta a una variable global a la que todas las funciones tienen acceso y se utiliza para evitar sobrescribir lo que previamente haya pintado otra función.

línea_horizontal:

Esta función dibuja una línea horizontal en el vector imagen. Sus argumentos de entrada son:

• uint8_t *imagen: puntero al vector imagen que después será representado en pantalla.

• int x_ini: coordenada x inicial de la línea horizontal. • int y_ini: línea de la pantalla donde se va a representar la recta. • int x_final: coordenada x final de la línea horizontal. • int grosor: define el grosor de la línea en pixeles. Puede variar entre 1 y 8 . • bool *pintado: puntero a la variable global que se utiliza para evitar sobrescribir lo

que haya podido dibujar en el vector imagen otra función.

línea_vertical:

De forma análoga a la función anterior, esta función dibuja una línea vertical en el vector imagen. Sus argumentos de entrada son:


• int x_ini: coordenada x de la línea vertical.

45

• int y_ini: coordenada y inicial de la línea vertical. • int y_final: coordenada y final de la línea vertical. • int grosor: define el grosor de la línea en pixeles. Puede variar entre 1 y 8 . • bool *pintado: puntero a la variable global que se utiliza para evitar sobrescribir lo


rectangulo:

En este caso, es un rectángulo lo que se dibuja en el vector imagen. Los argumentos de entrada son:


• int x_ini: coordenada x de la esquina superior izquierda del rectángulo. • int y_ini: coordenada y de la esquina superior izquierda del rectángulo. • int ancho: ancho del rectángulo (dimensión x). • int largo: alto del rectángulo (dimensión y). • int grosor: grosor de las aristas del rectángulo en pixeles. El grosor puede variar

entre 1 y 8. • bool *pintado: puntero a la variable global que se utiliza para evitar sobrescribir lo


pinta_texto:

Esta función escribe un texto en el vector imagen. Los argumentos de entrada son:

• int *caracteres: puntero a un vector tipo uint8_t que contenga los códigos ASCII de los caracteres que componen la cadena de texto que desea representar en la imagen.

• int longitud: tamaño del vector anterior. • uint8_t *imagen: puntero al vector imagen que después será representado en

pantalla. • int x_ini, y_ini: coordenadas superior izquierda donde comienza el texto. • bool *pintado: puntero a la variable global que se utiliza para evitar sobrescribir lo


Esta función pinta una línea de texto, es decir, si se desea escribir texto en varias líneas, deberá ser llamada una vez por cada línea.

Es responsabilidad del usuario que la línea de texto con su posición inicial concuerde y encaje con las dimensiones de la pantalla.

La fuente utilizada en esta función es la Arial tamaño 17.

pinta_numero:

En este caso los caracteres que se dibujan en el vector imagen solo son números (de 0 a 9) y un punto separador. De este modo, las componentes del vector al que apunta el puntero caracteres contiene directamente el número que se desea representar o un 10 en caso del punto separador. Por lo demás, la función es idéntica a pinta_texto.

La fuente usada para estos números son la Arial tamaño 70.

46

imagen_pequeña

Esta función sitúa y dibuja una ilustración en el vector imagen. Sus argumentos de entrada son:


• const uint8_t *imagenp: puntero al vector que contiene la “imagen pequeña” que se quiere incluir en el vector imagen.

• int x_ini, y_ini: coordenadas superior izquierda donde comienza la imagen pequeña. • int ancho: dimensión horizontal de la imagen pequeña. • int alto: dimensión vertical de la imagen pequeña. • bool *pintado: puntero a la variable global que se utiliza para evitar sobrescribir lo


47

4 RESULTADOS OBTENIDOS

En esta sección se mostrarán los resultados obtenidos con las diferentes funciones desarrolladas en las librerías descritas en el apartado anterior (Apartado 3. Librerías y funciones).


Con la librería de actualización de pantalla ya se puede representar en la pantalla una imagen previamente guardada en memoria. Dicha imagen debe tener las mismas dimensiones que la pantalla, es decir 264 x 176. A continuación, se ilustra el proceso de actualización de pantalla representando una imagen a pantalla completa. Debe recordarse que, para ello, se representa primero la imagen en “negativo”, después se alternan pantallas blancas y negras y, por último, la imagen final. De este modo, se evita dejar restos de la imagen representada anteriormente.

Además de representar una imagen, esta librería contiene la opción de limpiar pantalla. Como ya se ha mencionado el resultado de limpiar pantalla es una pantalla en blanco limpia de cualquier resto de imágenes representada con anterioridad.

4.2 Librería gráfica

Con la librería gráfica se pueden conseguir más variedad de representaciones. En esta sección se irán ilustrando los resultados gráficos de las distintas funciones contenidas en esta librería.

• Línea horizontal. Líneas horizontales de los distintos grosores posibles.

48

• Línea vertical. Líneas verticales de los distintos grosores disponibles.

Así como, la combinación de las dos anteriores: líneas horizontales y verticales de los distintos grosores disponibles:

• Rectángulo. Rectángulos de distintos tamaños y grosores.

49

• Pinta texto. Lista de todos los caracteres ASCII imprimibles accesible desde esta función.

• Pinta número. Lista de número, incluyendo punto separador, contenidos en esta función.

• Imagen pequeña. Combinación de imágenes de tamaños inferiores a las dimensiones de la pantalla.

50

Por último, a modo de ilustración, se muestra una posible “plantilla” con la combinación de los elementos anteriores.

• Combinación de los elementos anteriores.

51

5 TRABAJO FUTURO

En este apartado de trabajo futuro se incluyen posibles mejoras y ampliaciones de las funciones y librerías desarrolladas a lo largo del proyecto.

A continuación se enumeran algunas de estas posibles mejoras:

• Desarrollar una función que dibuje una línea entre dos puntos (sin necesidad de ser vertical ni horizontal). Las funciones desarrolladas en este proyecto para dibujar líneas están limitadas a líneas verticales u horizontales y sería de interés poder dibujar una línea entre dos puntos cualesquiera de la pantalla.

• Implementar una función en la librería gráfica que dibujara circunferencias dado las coordenadas del centro y el radio. En la librería gráfica se incluyen formas geométricas como rectas y rectángulos/cuadrados, pero no circunferencias. Podría ser de interés para según que aplicaciones poder dibujar circurferencias.

• Implementar varios tipos de fuentes. En la función pinta_texto solo hay disponible una fuente de un tamaño determinado. Podría ser de interés poder seleccionar entre distintos tamaños de fuentes, así como entre negrita cursiva o normal. Para ello habría que almacenar todos estos tipos de fuente y desarrollar un sistema que te permitiera navegar entre ellas para así usar la seleccionada por el usuario.

• Poder escribir texto en la pantalla en vertical. La función pinta_texto es capaz de escribir una línea de texto. Esta línea ocupa la dimensión horizontal de la pantalla obligándote a usar la pantalla en horizontal. La posibilidad de escribir la línea de texto en la dimensión vertical de la pantalla, te permitiría usarla en vertical.

• Justificar la línea de texto automáticamente. También podría resultar de interés introducir junto al texto la justificación que se desea (centrado, izquierda o derecha) y que la función pinta_texto se encargue de situar la línea de texto en el vector imagen para cumplir dicha justificación del texto.

• Por último, podría resultar de interés desarrollar una serie de plantillas prediseñadas orientadas a distintas utilidades. De este modo, si una plantilla contiene, por ejemplo, un texto, una imagen de unas determinadas dimensiones y un número, bastará con llamar a la función que administre las plantillas con el texto, número e imagen con el que se quiera personalizar para crear la imagen.

52

6 ANEXO A

En este anexo se incluyen el código de las funciones descritas en el apartado 3 ordenadas por librerías:

6.1 Librerías básicas

6.1.1 I2C

/* I2C Master Configuration Parameter */ volatile eUSCI_I2C_MasterConfig i2cConfig = { EUSCI_B_I2C_CLOCKSOURCE_SMCLK, // SMCLK Clock Source 0, EUSCI_B_I2C_SET_DATA_RATE_100KBPS, // Desired I2C Clock of 400khz 0, // No byte counter threshold EUSCI_B_I2C_SEND_STOP_AUTOMATICALLY_ON_BYTECOUNT_THRESHOLD // Autostop };

void initI2C(void) { /* I2C Clock Soruce Speed */ i2cConfig.i2cClk = 6000000; /* Select I2C function for I2C_SCL(P6.5) & I2C_SDA(P6.4) */ GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P6, GPIO_PIN5| GPIO_PIN4, GPIO_PRIMARY_MODULE_FUNCTION); /* Initializing I2C Master to SMCLK at 400kbs with autostop */ MAP_I2C_initMaster(EUSCI_B1_BASE, (const eUSCI_I2C_MasterConfig*)&i2cConfig); }

bool writeI2C(uint8_t ui8Addr, uint8_t ui8Reg, uint8_t *Data, uint8_t ui8ByteCount) { int i; for (i = 5000; i > 0; i--); /* Wait until ready to write */ while (MAP_I2C_isBusBusy(EUSCI_B1_BASE)); /* Assign Data to local Pointer */ pData = Data; /* Disable I2C module to make changes */ MAP_I2C_disableModule(EUSCI_B1_BASE); /* Setup the number of bytes to transmit + 1 to account for the register byte */ i2cConfig.byteCounterThreshold = ui8ByteCount + 1;

53

MAP_I2C_initMaster(EUSCI_B1_BASE, (const eUSCI_I2C_MasterConfig*)&i2cConfig); /* Load device slave address */ MAP_I2C_setSlaveAddress(EUSCI_B1_BASE, ui8Addr); /* Enable I2C Module to start operations */ MAP_I2C_enableModule(EUSCI_B1_BASE); /* Enable master STOP, TX and NACK interrupts */ MAP_I2C_enableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_STOP_INTERRUPT + EUSCI_B_I2C_NAK_INTERRUPT + EUSCI_B_I2C_TRANSMIT_INTERRUPT0); /* Set our local state to Busy */ ui8Status = eUSCI_BUSY; /* Send start bit and register */ MAP_I2C_masterSendMultiByteStart(EUSCI_B1_BASE,ui8Reg); /* Enable master interrupt for the remaining data */ MAP_Interrupt_enableInterrupt(INT_EUSCIB1); // NOW WAIT FOR DATA BYTES TO BE SENT while(ui8Status == eUSCI_BUSY){ #ifdef USE_LPM MAP_PCM_gotoLPM0(); #else __no_operation(); #endif } /* Disable interrupts */ MAP_I2C_disableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_STOP_INTERRUPT + EUSCI_B_I2C_NAK_INTERRUPT + EUSCI_B_I2C_TRANSMIT_INTERRUPT0); MAP_Interrupt_disableInterrupt(INT_EUSCIB1); if(ui8Status == eUSCI_NACK) { return(false); } else { return(true); } }

bool readI2C(uint8_t ui8Addr, uint8_t ui8Reg, uint8_t *Data, uint8_t ui8ByteCount) { int i; /* Todo: Put a delay */ for (i = 5000; i > 0; i--); /* Wait until ready */ while (MAP_I2C_isBusBusy(EUSCI_B1_BASE)); /* Assign Data to local Pointer */ pData = Data; /* Disable I2C module to make changes */

54

MAP_I2C_disableModule(EUSCI_B1_BASE); /* Setup the number of bytes to receive */ i2cConfig.byteCounterThreshold = ui8ByteCount; i2cConfig.autoSTOPGeneration = EUSCI_B_I2C_SEND_STOP_AUTOMATICALLY_ON_BYTECOUNT_THRESHOLD; MAP_I2C_initMaster(EUSCI_B1_BASE, (const eUSCI_I2C_MasterConfig*)&i2cConfig); /* Load device slave address */ MAP_I2C_setSlaveAddress(EUSCI_B1_BASE, ui8Addr); /* Enable I2C Module to start operations */ MAP_I2C_enableModule(EUSCI_B1_BASE); /* Enable master STOP and NACK interrupts */ MAP_I2C_enableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_STOP_INTERRUPT + EUSCI_B_I2C_NAK_INTERRUPT); /* Set our local state to Busy */ ui8Status = eUSCI_BUSY; /* Send start bit and register */ MAP_I2C_masterSendMultiByteStart(EUSCI_B1_BASE,ui8Reg); /* Enable master interrupt for the remaining data */ MAP_Interrupt_enableInterrupt(INT_EUSCIB1); /* NOTE: If the number of bytes to receive = 1, then as target register is *being shifted out during the write phase, UCBxTBCNT will be counted and will *trigger STOP bit prematurely If count is > 1, wait for the next TXBUF empty *interrupt (just after reg value has been shifted out */ while(ui8Status == eUSCI_BUSY) { if(MAP_I2C_getInterruptStatus(EUSCI_B1_BASE,EUSCI_B_I2C_TRANSMIT_INTERRUPT0)) { ui8Status = eUSCI_IDLE; } } ui8Status = eUSCI_BUSY; /* Turn off TX and generate RE-Start */ MAP_I2C_masterReceiveStart(EUSCI_B1_BASE); /* Enable RX interrupt */ MAP_I2C_enableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0); /* Wait for all data be received */ while(ui8Status == eUSCI_BUSY) { #ifdef USE_LPM MAP_PCM_gotoLPM0(); #else __no_operation(); #endif } /* Disable interrupts */ MAP_I2C_disableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_STOP_INTERRUPT + EUSCI_B_I2C_NAK_INTERRUPT + EUSCI_B_I2C_RECEIVE_INTERRUPT0); MAP_Interrupt_disableInterrupt(INT_EUSCIB1); if(ui8Status == eUSCI_NACK) {

55

return(false); } else { return(true); } }

6.1.2 SPI

/* SPI Master Configuration Parameter */ const eUSCI_SPI_MasterConfig spiMasterConfig = { EUSCI_B_SPI_CLOCKSOURCE_SMCLK, // SMCLK Clock Source 48000000, // SMCLK = DCO = 48MHZ 12000000, // SPICLK = 12MHZ EUSCI_B_SPI_MSB_FIRST, // MSB First EUSCI_B_SPI_PHASE_DATA_CHANGED_ONFIRST_CAPTURED_ON_NEXT, // Phase EUSCI_B_SPI_CLOCKPOLARITY_INACTIVITY_HIGH, // High polarity EUSCI_B_SPI_3PIN // 3Wire SPI Mode };

void initSPI(void) { /* Selecting P1.5 P1.6 and P1.7 in SPI mode */ GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN5 | GPIO_PIN6 | GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION); /* CS= P5.0 */ GPIO_setAsOutputPin(GPIO_PORT_P5, GPIO_PIN0); GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN0); /* Configuring SPI in 3wire master mode */ SPI_initMaster(EUSCI_B0_BASE, &spiMasterConfig); /* Enable SPI module */ SPI_enableModule(EUSCI_B0_BASE); }

void SPI_off(void) { Interrupt_disableInterrupt(INT_EUSCIB0); Interrupt_disableSleepOnIsrExit(); SPI_disableModule(EUSCI_B0_BASE); }

void SPI_send( const uint8_t *buffer, uint16_t length) { /* CS LOW */ GPIO_setOutputLowOnPin(GPIO_PORT_P5, GPIO_PIN0); /* Polling to see if the TX buffer is ready */ while(!(SPI_getInterruptStatus(EUSCI_B0_BASE,EUSCI_B_SPI_TRANSMIT_INTERRUPT)));

56

/* send all data */ for ( i = 0; i < length; i++) { SPI_transmitData(EUSCI_B0_BASE, *(buffer+i)); while(!(SPI_getInterruptStatus(EUSCI_B0_BASE,EUSCI_B_SPI_TRANSMIT_INTERRUPT))); } /* CS HIGH */ GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN0); }

uint8_t SPI_read(const uint8_t *buffer, uint16_t length) { localbuffer=buffer; /* CS LOW */ GPIO_setOutputLowOnPin(GPIO_PORT_P5, GPIO_PIN0); /* Polling to see if the TX buffer is ready */ while(!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); SPI_transmitData(EUSCI_B0_BASE, *(localbuffer+0)); /* Polling to see if the TX buffer is ready */ while(!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); while (1){ SPI_transmitData(EUSCI_B0_BASE, *(localbuffer+1)); /* USCI_B0 TX buffer ready? */ while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); RXData = SPI_receiveData(EUSCI_B0_BASE); if(RXData!=0x00){ break; } } GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN0); //CS HIGH return RXData; }


void setFactor(int temperature) { // stage1: repeat, step, block // stage2: repeat, t1, t2 // stage3: repeat, step, block static const compensation_type compensation_270[3] = {

57

{ 2, 8, 64, 4, 392, 392, 2, 8, 64 }, // 0 ... 10 Celcius { 2, 4, 32, 4, 196, 196, 2, 4, 32 }, // 10 ... 40 Celcius { 4, 8, 64, 4, 196, 196, 4, 8, 64 } // 40 ... 50 Celcius }; if (temperature < 10) { temperature_offset = 0; } else if (temperature > 40) { temperature_offset = 2; } else { temperature_offset = 1; } compensation = compensation_270[temperature_offset]; }

EPD_error EPD_ON (void) { // assume ok status = EPD_OK; uint8_t ChannelSelect[9]={0x72, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xfe, 0x00, 0x00}; uint8_t *pChannelSelect=&ChannelSelect[0]; /*Power up sequence*/ GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6); GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN4); GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN3); GPIO_setOutputLowOnPin(GPIO_PORT_P3, GPIO_PIN3); GPIO_setOutputLowOnPin(GPIO_PORT_P5, GPIO_PIN0); initSPI(); delay_ms(5);//delay 5ms GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN4); //Pin panel on HIGH delay_ms(10);//delay 10 ms GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN6); //Pin Reset HIGH GPIO_setOutputHighOnPin(GPIO_PORT_P3, GPIO_PIN3); //Pin Border HIGH GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN0); //Pin CS HIGH delay_ms(5);// delay 5ms (sale en manual EPD) GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6); //Pin Reset LOW delay_ms(5);//delay 5ms (sale en manual EPD) GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN6); //Pin Reset HIGH delay_ms(5);//Delay 5ms (sale en manual EPD) // wait for COG to become ready while(GPIO_INPUT_PIN_HIGH==GPIO_getInputPinValue(GPIO_PORT_P3, GPIO_PIN2));

//Delay_us(10); for (i = 1000; i > 0; i--); data[0]=0x71; data[1]=0x00; int cog_id=SPI_read(pdata,2); for (i = 2000; i > 0; i--); // Delay before next transmission cog_id=SPI_read(pdata,2);

58

if (0x02 != (0x0f & cog_id)) { status = EPD_UNSUPPORTED_COG; power_off(); return status; } // Disable OE CI[0]=0x70; CI[1]=0x02; data[0]=0x72; data[1]=0x40; SPI_send( pCI, 2); SPI_send( pdata, 2); /* Check breakage */ CI[0]=0x70; CI[1]=0x0f; data[0]=0x73; data[1]=0x00; SPI_send( pCI,2); SPI_read( pdata,2); int broken_panel= RXData; if (0x00 == (0x80 & broken_panel)) { status = EPD_PANEL_BROKEN; power_off(); return status; }

/* Power saving mode*/ CI[0]=0x70; CI[1]=0x0b; data[0]=0x72; data[1]=0x02; SPI_send( pCI, 2); SPI_send( pdata, 2); /* Chanel select */ CI[0]=0x70; CI[1]=0x01; SPI_send(pCI,2); SPI_send(pChannelSelect,9); /* high power mode osc */ CI[0]=0x70; CI[1]=0x07; data[0]=0x72; data[1]=0xd1; SPI_send( pCI, 2); SPI_send( pdata, 2);

59

/* Power Setting */ CI[0]=0x70; CI[1]=0x08; data[0]=0x72; data[1]=0x02; SPI_send( pCI , 2); SPI_send( pdata, 2); /* Set Vcom level */ CI[0]=0x70; CI[1]=0x09; data[0]=0x72; data[1]=0xc2; SPI_send( pCI, 2); SPI_send( pdata, 2); /* Power Setting */ CI[0]=0x70; CI[1]=0x04; data[0]=0x72; data[1]=0x03; SPI_send( pCI , 2); SPI_send( pdata, 2); /* Driver Latch on */ CI[0]=0x70; CI[1]=0x03; data[0]=0x72; data[1]=0x01; SPI_send( pCI , 2); SPI_send( pdata, 2); /* Driver Latch off */ CI[0]=0x70; CI[1]=0x03; data[0]=0x72; data[1]=0x00; SPI_send( pCI , 2); SPI_send( pdata, 2); delay_ms(5);//delay 5ms bool dc_ok = false; for (i = 0; i < 4; ++i) { /* charge pump positive voltage on - VGH/VDL on */ CI[0]=0x70; CI[1]=0x05; data[0]=0x72; data[1]=0x01; SPI_send( pCI, 2); SPI_send( pdata, 2);

60

delay_ms(240);// Delay_ms(240); /* charge pump negative voltage on - VGL/VDL on */ CI[0]=0x70; CI[1]=0x05; data[0]=0x72; data[1]=0x03; SPI_send( pCI, 2); SPI_send( pdata, 2); delay_ms(90);// Delay_ms(40); /* charge pump Vcom on - Vcom driver on */ CI[0]=0x70; CI[1]=0x05; data[0]=0x72; data[1]=0x0f; SPI_send( pCI, 2); SPI_send( pdata, 2); delay_ms(40);// Delay_ms(40); /*check DC/DC */ CI[0]=0x70; CI[1]=0x0F; data[0]=0x73; data[1]=0x00; SPI_send( pCI, 2); SPI_read( pdata, 2); int dc_state = RXData; if (0x40 == (0x40 & dc_state)) { dc_ok = true; break; } } if (!dc_ok) { // output enable to disable CI[0]=0x70; CI[1]=0x02; data[0]=0x72; data[1]=0x40; SPI_send( pCI, 2); SPI_send( pdata, 2); status = EPD_DC_FAILED; power_off(); return status; } //SPI_off(); return status; }

61

void EPD_off (void) { /* WRITE A NOTHING FRAME************/ uint16_t lin; for (lin = 0; lin < 176; ++lin) { line(lin, 0, 0x00, EPD_normal, 0x00); } /***************************************************************************/ /* WRITE A DUMMY LINE **************/ line(0x7fffu, 0, 0x00, EPD_normal, 0x00); /***************************************************************************/ delay_ms(25); GPIO_setOutputLowOnPin(GPIO_PORT_P3, GPIO_PIN3); // Border control low delay_ms(200);// Delay 200ms GPIO_setOutputHighOnPin(GPIO_PORT_P3, GPIO_PIN3);//Border control high initSPI(); CI[0]=0x70; CI[1]=0x0B; data[0]=0x72; data[1]=0x00; SPI_send( pCI, 2); SPI_send( pdata, 2); /* Latch reset turn on */ CI[1]=0x03; data[1]=0x01; SPI_send( pCI, 2); SPI_send( pdata, 2); /* Power off Chargepump Vcom off */ CI[1]=0x05; data[1]=0x03; SPI_send( pCI, 2); SPI_send( pdata, 2); /* Power off Chargepump negative voltage VGL & VDL off */ CI[1]=0x05; data[1]=0x01; SPI_send( pCI, 2); SPI_send( pdata, 2); delay_ms(300);// Delay 300 ms /* Discharge internal */ CI[1]=0x04; data[1]=0x80; // en ejemplo arduino pone 0x83 SPI_send( pCI, 2); SPI_send( pdata, 2); /* Power off Chargepump positive voltage VGL & VDL off */

62

CI[1]=0x05; data[1]=0x00; SPI_send( pCI, 2); SPI_send( pdata, 2); /* Turn off osc */ CI[1]=0x07; data[1]=0x01; SPI_send( pCI, 2); SPI_send( pdata, 2); delay_ms(50);//Delay 50ms power_off(); } void power_off(void) { /*Power off sequence*/ GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN6); //reset GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN4); //panel on GPIO_setOutputLowOnPin(GPIO_PORT_P3, GPIO_PIN3); // border //SPI_off SPI_off(); GPIO_setOutputLowOnPin(GPIO_PORT_P5, GPIO_PIN0); // CS /* Pulse Discharge pin */ GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN3); delay_ms(150);//Delay 150 ms GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN3); } void frame_fixed_timed(uint8_t fixed_value, long stage_time) { do { uint8_t lin; for (lin = 0; lin < 176/* Line per display*/ ; ++lin) { line(176 - lin - 1, 0, fixed_value, EPD_normal, 0x00); } stage_time -= 89; // tiempo que tardo en pintar todas las líneas } while (stage_time > 0); } void frame_fixed_13(uint8_t value, EPD_stage stage){ int repeat;

63

int step; int block; int n; int lin; if (EPD_inverse == stage) { // stage 1 repeat =compensation.stage1_repeat; step = compensation.stage1_step; block = compensation.stage1_block; } else { // stage 3 repeat = compensation.stage3_repeat; step = compensation.stage3_step; block = compensation.stage3_block; } int total_lines = 176; //lines_per_display; for ( n = 0; n < repeat; ++n) { int block_begin = 0; int block_end = 0; while (block_begin < total_lines) { block_end += step; block_begin = block_end - block; if (block_begin < 0) { block_begin = 0; } else if (block_begin >= total_lines) { break; } bool full_block = ((block_end - block_begin) == block); for (lin = block_begin; lin < block_end; ++lin) { if (lin >= total_lines) { break; } if (full_block && (lin < (block_begin + step))) { line(lin, 0, 0x00, EPD_normal, 0x00); } else { line(lin, 0, value, EPD_normal, 0x00); } } } } } void frame_data_13(const uint8_t *image, EPD_stage stage) { int repeat; int step; int block; int lin;

64

int n; if (EPD_inverse == stage) { // stage 1 repeat = compensation.stage1_repeat; step = compensation.stage1_step; block = compensation.stage1_block; } else { // stage 3 repeat = compensation.stage3_repeat; step = compensation.stage3_step; block = compensation.stage3_block; } int total_lines = 176; for ( n = 0; n < repeat; ++n) { int block_begin = 0; int block_end = 0; while (block_begin < total_lines) { block_end += step; block_begin = block_end - block; if (block_begin < 0) { block_begin = 0; } else if (block_begin >= total_lines) { break; } bool full_block = (block_end - block_begin == block); for (lin = block_begin; lin < block_end; ++lin) { if (lin >= total_lines) { break; } if (full_block && (lin < (block_begin + step))) { line(lin, 0, 0x00, EPD_normal, 0x00); } else { line(lin, &image[lin*33], 0x00, stage, 0x00); } } } } } void frame_stage2() { uint16_t i; for ( i = 0; i < compensation.stage2_repeat; ++i) { frame_fixed_timed(0xff, compensation.stage2_t1); frame_fixed_timed(0xaa, compensation.stage2_t2); } } void line (uint16_t line, const uint8_t *adata, uint8_t fixed_value, EPD_stage stage, uint8_t border_byte) { uint16_t b;

65

int c; uint8_t pixels; //initSPI(); /* send data/borderbyte */ CI[0]=0x70; CI[1]=0x0a; data[0]=0x72; data[1]=border_byte; SPI_send( pCI, 2); //CS Low GPIO_setOutputLowOnPin(GPIO_PORT_P5, GPIO_PIN0); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); SPI_transmitData(EUSCI_B0_BASE, 0x72); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); SPI_transmitData(EUSCI_B0_BASE, border_byte); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); /* Odd pixels */ for (b = 33/*byte per line = 264/8*/; b > 0; b--) { if(0!= adata){ pixels = adata[b - 1]; switch(stage) { case EPD_inverse: // B -> W, W -> B pixels ^= 0xff; break; case EPD_normal: // B -> B, W -> W break; } pixels = 0xaa | pixels; SPI_transmitData(EUSCI_B0_BASE, pixels); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); }else{ SPI_transmitData(EUSCI_B0_BASE, fixed_value); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); } } /* scan line */ int scan_pos = (176 - line - 1) >> 2; int scan_shift = (line & 0x03) << 1;

66

for ( c = 0; c < 44/*bytes_per_scan= 176/4*/; c++) { if (scan_pos == c) { SPI_transmitData(EUSCI_B0_BASE, 0x03 << scan_shift); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); } else { SPI_transmitData(EUSCI_B0_BASE, 0x00); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); } } /* even pixels */ for (b = 0; b < 33; b++) { if(0!= adata){ uint8_t pixels = adata[b]; switch(stage) { case EPD_inverse: // B -> W, W -> B pixels ^= 0xff; break; case EPD_normal: // B -> B, W -> W break; } pixels >>= 1; pixels |= 0xaa; pixels = ((pixels & 0xc0) >> 6) | ((pixels & 0x30) >> 2) | ((pixels & 0x0c) << 2) | ((pixels & 0x03) << 6); SPI_transmitData(EUSCI_B0_BASE, pixels); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); } else{ SPI_transmitData(EUSCI_B0_BASE, fixed_value); while (!(SPI_getInterruptStatus(EUSCI_B0_BASE, EUSCI_B_SPI_TRANSMIT_INTERRUPT))); } } // CS high GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN0); // output data to panel CI[0]=0x70; CI[1]=0x02; data[0]=0x72;

67

data[1]=0x07; SPI_send( pCI, 2); SPI_send( pdata, 2); //SPI_off(); }

6.3 Librería Gráfica

void linea_horizontal ( uint8_t *text, int x_ini, int y_ini, int x_final, int grosor, bool *pintado) { int n; int x=0; int lin=1; /** recorro toda la pantalla**/ for(n=0;n<5808;n++) { if( lin<y_ini || lin >=y_ini +grosor || x<=x_ini ||x>x_final ) { if(*pintado==false){ *(text+n)=0x00; } }else{ *(text+n)=0xff; //negro } x++; if(n== 32+33*(lin-1)) { lin++; // actualizo la línea por la que voy; x=0; } } if(*pintado==false){ *pintado=true; } }

68

void linea_vertical ( uint8_t *text, int x_ini, int y_ini, int y_final, uint8_t grosor, bool *pintado) { int n; int x=0; int lin=1; uint8_t A=0x01; uint8_t g=0x00; int i; for(i=0;i<grosor;i++){ g=g | A<<i; } g=g<<(8-grosor); /** recorro toda la pantalla**/ for(n=0;n<5808;n++) { if( lin<y_ini || lin >=y_final || x<x_ini || x>x_ini ) { if(*pintado==false){ *(text+n)=0x00; } }else{ *(text+n)=g; //pinto línea } x++; if(n== 32+33*(lin-1)) { lin++; // actualizo la línea por la que voy; x=0; } } if(*pintado==false){ *pintado=true; } } void rectangulo ( uint8_t *text, int x_ini, int y_ini,int ancho, int alto, int grosor, bool *pintado) { linea_vertical ( text, x_ini, y_ini, y_ini + alto, grosor, pintado); linea_vertical ( text, x_ini + ancho , y_ini, y_ini + alto, grosor, pintado); linea_horizontal ( text, x_ini, y_ini, x_ini + ancho, grosor, pintado); linea_horizontal ( text, x_ini, y_ini + alto -grosor, x_ini + ancho, grosor, pintado); }

69

void imagen_pequeña ( uint8_t *text, const uint8_t *imagenp, int x_ini, int y_ini,int ancho, int alto, bool *pintado) { int n; int c=0; int lin=1; int x=0; /** recorro toda la pantalla**/ for(n=0;n<5808;n++) { if(lin<y_ini || lin >=y_ini + alto || x<x_ini || x>=x_ini+ancho) { if(*pintado==false){ *(text+n)=0x00; } }else{ *(text+n)=*(imagenp+c); //imagen de la cadena c++; } x++; if(n== 32+33*(lin-1)) { lin++; // actualizo la línea por la que voy; x=0; } } if(*pintado==false){ *pintado=true; } }

70

void pinta_texto (int *caracter, int longitud, uint8_t *text, int x_ini, int y_ini, bool *pintado) { int i; int d=0; int c=0; int cc=0; // componente que recorre el vector cad int x=0; int lin=1; // recorre pantalla linea por linea int n; // recorre pantalla byte por byte int ancho_caracter; int ancho_total=0; int alto=fontAriB17.height; /***Calculo el ancho en bytes de la cadena de texto **/ for(i=0;i<longitud;i++) { ancho_caracter= (fontAriB17.offset[*(caracter+i)-32+1] - fontAriB17.offset[*(caracter+i)-32])/alto; ancho_total+=ancho_caracter; } /******** Crear la imagen de la cadena de texto altura height, anchura ancho total******/ int long_cad=ancho_total*alto; //bytes que va a ocupar la cadena uint8_t *cad; cad= malloc(long_cad*sizeof(uint8_t)); for(cc=0;cc<alto;cc++){ for(i=0;i<longitud;i++){ ancho_caracter= (fontAriB17.offset[*(caracter+i)-32+1] - fontAriB17.offset[*(caracter+i)-32])/alto; for(d=0;d<ancho_caracter;d++){ *(cad+c)=fontAriB17Data[ fontAriB17.offset[*(caracter+i)-32] + d + cc*ancho_caracter]; c++; } } }

71

/** recorro toda la pantalla**/ c=0; for(n=0;n<5808;n++) { if(lin<y_ini || lin >=(y_ini+alto)||x<x_ini || x>=(x_ini+ancho_total)) { if(*pintado==false){ *(text+n)=0x00; } }else{ *(text+n)=*(cad+c); //imagen de la cadena c++; } x++; if(n== 32+33*(lin-1)) { lin++; // actualizo la línea por la que voy; x=0; } } free(cad); if(*pintado==false){ *pintado=true; } } void pinta_numero (int *caracter, int longitud, uint8_t *text, int x_ini, int y_ini, bool *pintado) { int i; int d=0; int c=0; int cc=0; // componente que recorre el vector cad int x=0; int lin=1; // recorre pantalla linea por linea int n; // recorre pantalla byte por byte int ancho_caracter; int ancho_total=0; int alto=fontArinum70.height; /***Calculo el ancho en bytes de la cadena de texto **/ for(i=0;i<longitud;i++) { ancho_caracter= (fontArinum70.offset[*(caracter+i)+1] - fontArinum70.offset[*(caracter+i)])/alto; ancho_total+=ancho_caracter; }

72

/******** Crear la imagen de la cadena de texto altura height, anchura ancho total******/ int long_cad=ancho_total*alto; //bytes que va a ocupar la cadena uint8_t *cadnum; cadnum= malloc(long_cad*sizeof(uint8_t)); for(cc=0;cc<alto;cc++){ for(i=0;i<longitud;i++){ ancho_caracter= (fontArinum70.offset[*(caracter+i)+1] - fontArinum70.offset[*(caracter+i)])/alto; for(d=0;d<ancho_caracter;d++){ *(cadnum+c)=fontArinum70Data[ fontArinum70.offset[*(caracter+i)] + d + cc*ancho_caracter]; c++; } } } /** recorro toda la pantalla**/ c=0; for(n=0;n<5808;n++) { if( lin<y_ini || lin >=(y_ini+alto) || x<x_ini || x>=(x_ini+ancho_total) ) { if(*pintado==false){ *(text+n)=0x00; } }else{ *(text+n)= *(cadnum+c); //imagen de la cadena c++; } x++; if(n== 32+33*(lin-1)) { lin++; // actualizo la línea por la que voy; x=0; } } free(cadnum); if(*pintado==false){ *pintado=true; } }

73

REFERENCIAS

[1] Datasheet del MSP432P401x, Product Preview. Texas Instruments. [2] MSP432 Peripheral Driver Library. USER’S GUIDE, Texas Instruments. [3] E-paper display COG Driver Interface Timing for wide temperature of 1.44’’, 2’’ and 2.7’’ EPD with G2 COG and Aurora MA Film. Pervasive displays. [4] Product Specifications EM027BS013. Pervasive displays. [5] LM75B. Digital temperature sensor and thermal watchdog. Datasheet product. [6] Texas instruments E2E community forum msp432. [7] E-paper display adapter board. Rev D. Embedded Artists. [8] https://github.com/embeddedartists/gratis, web donde se puede encontrar código de ejemplo para arduino

https://github.com/embeddedartists/gratis

placa de evaluación de pantallas de tinta electrónica para...

Documents