Conexión de tres arduino vía i2c. PCF8574P: Conecte los botones a Arduino a través del bus I2C o Luke Skywalker Strikes

Descripción de la biblioteca Wire

Esta biblioteca le permite interactuar con dispositivos I2C / TWI. En las placas Arduino con el diseño R3 (pinout 1.0), SDA (línea de datos) y SCL (línea de señal de reloj) están en pines cerca del pin AREF. Arduino Due tiene dos interfaces I2C/TWI: SDA1 y SCL1 están cerca del pin AREF, y las líneas adicionales están en los pines 20 y 21.

La siguiente tabla muestra dónde se encuentran los pines TWI en diferentes placas Arduino.

A partir de Arduino 1.0, esta biblioteca hereda las funciones de Stream, haciéndola compatible con otras bibliotecas de lectura/escritura. Debido a esto, send() y receive() han sido reemplazados por read() y write() .

Nota

Hay versiones de 7 y 8 bits de direcciones I2C. 7 bits identifican el dispositivo y el octavo bit determina si el dispositivo se está escribiendo o leyendo. La biblioteca Wire utiliza direcciones de 7 bits. Si tiene una hoja de datos o un ejemplo de código que usa una dirección de 8 bits, debe eliminar el bit menos significativo (es decir, cambiar el valor un bit a la derecha) para obtener una dirección de 0 a 127. Sin embargo, las direcciones 0 a 7 no se usan, ya que están reservados, por lo que la primera dirección que se puede usar es 8. Tenga en cuenta que se requieren resistencias pull-up cuando se conectan los pines SDA/SCL. Ver ejemplos para más detalles. La placa MEGA 2560 tiene resistencias pull-up en los pines 20 y 21.

Descripción de los métodos

Wire.begin()

Descripción

Inicializa la biblioteca Wire y se conecta al bus I2C como maestro o esclavo. Por lo general, solo debe llamarse una vez.

Sintaxis

Wire.begin(dirección)

Opciones

dirección: dirección esclava de 7 bits (opcional); si no se configura, la placa se conecta al bus como maestro.

Valor devuelto

Ejemplo

Vea ejemplos de los métodos onReceive() y onRequest() para ejemplos de dispositivos esclavos. Para obtener ejemplos maestros, consulte los ejemplos de otros métodos. .

Cable.solicitudDesde()

Descripción

Utilizado por el maestro para solicitar bytes del esclavo. Estos bytes se pueden obtener utilizando los métodos available() y read().

Si este argumento es verdadero, requestFrom() envía un mensaje STOP después de la solicitud, liberando el bus I2C.

Si este argumento es falso, requestFrom() envía un mensaje de REINICIO después de la solicitud. El bus no se libera, lo que impide que otro dispositivo maestro intervenga entre mensajes. Esto permite que un solo maestro envíe múltiples solicitudes mientras controla el bus.

Sintaxis

Wire.requestFrom(dirección, cantidad)

Wire.requestFrom(dirección, cantidad, parada)

Opciones

• dirección: dirección de 7 bits del dispositivo desde el que se solicitan los bytes;
• cantidad: el número de bytes solicitados;
• detener: booleano. true envía un mensaje STOP después de una solicitud. falso envía un mensaje de REINICIO después de la solicitud, manteniendo viva la conexión.

Valor devuelto

byte: número de bytes devueltos por el esclavo.

Ejemplo

Wire.beginTransmission()

Descripción

Inicia la transmisión al dispositivo esclavo I2C en la dirección dada. Después de eso, la secuencia de bytes a transmitir se pone en cola usando la función write() y se transmite usando la llamada endTransmission().

Sintaxis

Wire.beginTransmission(dirección)

Opciones

dirección: dirección de 7 bits del dispositivo al que transferir datos.

Valor devuelto

Ejemplo

Cable.endTransmission()

Descripción

Finaliza la transmisión al esclavo que inició el método beginTransmission() y transfiere los bytes que el método write() puso en cola.

Por compatibilidad con ciertos dispositivos I2C, desde Arduino 1.0.1, requestFrom() toma un argumento de tipo de datos booleano que cambia su comportamiento.

Si este argumento es verdadero, requestFrom() envía un mensaje DETENER después de pasar, liberando el bus I2C.

Si este argumento es falso, requestFrom() envía un mensaje de REINICIO después de pasar. El bus no se libera, lo que impide que otro dispositivo maestro intervenga entre mensajes. Esto permite que un solo maestro envíe múltiples transmisiones siempre que controle el bus.

Este argumento por defecto es verdadero.

Sintaxis

Cable.endTransmission()

Wire.endTransmission (detener)

Opciones

detener: booleano. true envía un mensaje STOP después de la transmisión. falso envía un mensaje de REINICIO después de la transmisión, manteniendo viva la conexión.

Valor devuelto

byte , que indica el estado de la transferencia:

• 0: éxito;
• 1: los datos son demasiado largos para llenar el búfer de envío;
• 2: recibió NACK al transmitir la dirección;
• 3: recibió NACK al transmitir datos;
• 4: otros errores.

Ejemplo

Consulte el método write() para ver un ejemplo.

Alambre.escribir()

Descripción

Escribe datos del esclavo en respuesta a una solicitud del maestro, o pone en cola bytes para la transmisión del maestro al esclavo (entre llamadas a beginTransmission() y endTransmission()).

Sintaxis

Cable.escribir(valor)

cable.escribir(cadena)

Wire.write(datos, longitud)

Opciones

• valor: valor a enviar, un byte.
• cadena: la cadena a enviar, una secuencia de bytes.
• datos: matriz de datos a enviar, bytes.
• longitud: número de bytes a transferir.

Valor devuelto

byte: write() devuelve el número de bytes escritos, aunque no es necesario leer este número.

#incluir ejemplo byte valor = 0; void setup() ( Wire.begin(); // conectar al bus i2c ) void loop() ( Wire.beginTransmission(44); // transferir al dispositivo #44 (0x2c) // dirección del dispositivo especificada en la hoja de datos de Wire. write(val); // envía byte de valor Wire.endTransmission(); // detiene transmisión val++; // incrementa valor if(val == 64) // si llegamos al valor 64 (max) ( val = 0; / / empezar de nuevo ) retraso (500); )

Cable.disponible()

Descripción

Devuelve el número de bytes disponibles para recibir con read() . Este método debe invocarse en el maestro después de llamar a requestFrom() o en el esclavo dentro del controlador onReceive().

Sintaxis

Cable.disponible()

Opciones

Valor devuelto

El número de bytes disponibles para lectura.

Ejemplo

Consulte el método read() para ver un ejemplo.

Alambre.read()

Descripción

Lee un byte que se pasó del esclavo al maestro después de llamar a requestFrom(), o que se pasó del maestro al esclavo.

Sintaxis

Opciones

Valor devuelto

byte: siguiente byte recibido.

#incluir ejemplo byte valor = 0; void setup() ( Wire.begin(); // conectar al bus i2c (la dirección del maestro es opcional) Serial.begin(9600); // configurar el puerto serie para la salida) void loop() ( Wire.requestFrom(2, 6); // solicita 6 bytes del esclavo #2 while(Wire.disponible()) // el esclavo puede enviar menos de lo solicitado ( char c = Wire.read(); // acepta byte como carácter Serial.print (c) ; // imprime caracter ) retraso(500); )

Wire.setClock()

Descripción

Cambia la frecuencia del reloj para la comunicación I2C. Los dispositivos esclavos I2C no tienen una frecuencia de reloj operativa mínima, pero se suele utilizar 100 kHz.

Sintaxis

Wire.setClock(frecuencia del reloj)

Opciones

clockFrequency: el valor de frecuencia (en hercios) de la señal de reloj. Los valores aceptados son 100000 (modo estándar) y 400000 (modo rápido). Algunos procesadores también admiten 10000 (modo de baja velocidad), 1000000 (modo plus rápido) y 3400000 (modo de alta velocidad). Para asegurarse de que el modo requerido sea compatible, consulte la documentación técnica del procesador específico.

Valor devuelto

Conectar.onReceive()

Descripción

Registra una función que se llamará cuando el dispositivo esclavo reciba una transmisión del maestro.

Sintaxis

Wire.onReceive (controlador)

Opciones

handler: la función que se llamará cuando el esclavo reciba datos; debería tomar un parámetro int (la cantidad de bytes leídos del maestro) y no devolver nada, es decir:

void myHandler(int numBytes)

Valor devuelto

Ejemplo

#incluir void setup() ( Wire.begin(8); // conectar a la dirección de bus i2c #8 Wire.onReceive(receiveEvent); // registrar el controlador de eventos Serial.begin(9600); // configurar el puerto serie para la salida) void loop () ( delay(100); ) // función que se ejecutará cada vez que se reciban datos del maestro // esta función se registra como un controlador de eventos, consulte setup() void receiveEvent(int howMany) ( while (1< Wire.available()) // пройтись по всем до последнего { char c = Wire.read(); // принять байт как символ Serial.print(c); // напечатать символ } int x = Wire.read(); // принять байт как целое число Serial.println(x); // напечатать число }

Conectar.onRequest()

Descripción

Registra una función que se llamará cuando el maestro solicite datos del esclavo.

Sintaxis

Wire.onRequest (controlador)

Opciones

handler: la función a llamar, no toma parámetros y no devuelve nada, es decir:

anular miManejador()

Valor devuelto

Ejemplo

Código para una placa Arduino que actúa como esclava:

#incluir void setup() ( Wire.begin(8); // conectar a la dirección de bus i2c #8 Wire.onRequest(requestEvent); // registrar el controlador de eventos ) void loop() ( delay(100); ) // función, que se ejecutará cada vez que el maestro // solicite datos // esta función se registra como un controlador de eventos, consulte setup() void requestEvent() ( Wire.write("hello "); // responde con un mensaje )

El protocolo de intercambio de datos I2C fue desarrollado una vez por Philips. El nombre I2C proviene del inglés Iner-IC control o, en otras palabras, inter-chip control, Inter-IC, IIC (I2C) es el nombre del mismo protocolo.

Este protocolo o interfaz proporciona recepción y transmisión de información (datos) de alta calidad desde varios dispositivos diferentes, por ejemplo, puede medir la temperatura y controlar simultáneamente un potenciómetro digital. La comunicación se realiza mediante programación, el algoritmo para comunicarse con el sensor a través del protocolo I2C se escribe en el programa Arduino (boceto).

Hay adaptadores especiales que le permiten conectar otros dispositivos, por ejemplo, al tener un adaptador, puede conectar una pantalla LCD arduino 1602 (16x2) utilizando el protocolo i2c a través de dos cables. A pedido de LCD i2c, hay mucha información en Internet, aquí hay un ejemplo de cómo debería verse el adaptador de pantalla http://www.ebay.com/itm/310565362720

Cuando se trabaja en esta interfaz, un dispositivo es el maestro y el otro es el esclavo. El dispositivo maestro inicia la transmisión y genera las señales necesarias para la sincronización.

Vema, a su vez, depende del maestro e inicia la transferencia de datos solo después de recibir un comando del maestro.

El dispositivo conectado al bus I2C tiene su propia dirección única. Es en esta dirección que se accede al dispositivo maestro.

Un ejemplo de conexión de sensores usando el protocolo I2C

La conexión se realiza a través de dos cables: SCL - señal de reloj o señal de reloj y SDA - señal de datos. Al mismo tiempo, cualquier cantidad de sensores diferentes (dispositivos esclavos) con su propia identificación única se pueden conectar al bus I2C.

El conocimiento comienza con una biblioteca especialmente escrita para estos fines, cuyo nombre es Wire. Antes de comenzar a trabajar, debe importarse al proyecto, tiene comandos o métodos especiales para "comunicarse" con los dispositivos.

Para intercambiar datos con dispositivos, debe conocer su identificación. Diferentes dispositivos pueden tener diferentes longitudes de dirección (id) de bits 8 o 7. La biblioteca Wire utiliza direcciones de bits 7.

Los dispositivos esclavos están conectados a los pines de la placa Arduino. Cada versión de Arduino tiene sus propios pines I2C

• UNO - A4(SDA), A5(SCL);
• Mega - 20 (SDA), 21 (SCL);
• Leonardo-2 (SDA), 3 (SCL);
• Vencimiento: 20 (SDA), 21 (SCL), SDA1, SCL1;

Ejemplo de código de programa para controlar un potenciómetro digital utilizando la biblioteca Wire

Este ejemplo muestra cómo establecer un valor de resistencia específico en un potenciómetro digital utilizando la biblioteca Wire. La configuración de un valor específico se realiza mediante la variable val.

#incluir void setup() ( Wire.begin(); // unirse al bus i2c (dirección opcional para el maestro) ) byte val = 0; void loop() ( Wire.beginTransmission(44); // transmite al dispositivo #44 (0x2c) // la dirección del dispositivo se especifica en la hoja de datos Wire.write(byte(0x00)); // envía el byte de instrucción Wire.write(val ); // envía el byte de valor del potenciómetro Wire.endTransmission(); // deja de transmitir val++; // incrementa el valor si (val == 64) // si alcanza la posición 64 (máx.) ( val = 0; // comienza de nuevo desde valor más bajo) retraso (500);)

Video del trabajo de I2C y Arduino. Parte 1

Con clasificaciones de 10 Ohm a 1 MΩ);

2 resistencias de 4,7 kOhm (del mismo conjunto);

cables de conexión (por ejemplo, aquí hay un buen conjunto);

ordenador con Arduino IDE.

1 Descripción interfaz I2C

El protocolo de comunicación en serie IIC (también llamado I2C - Inter-Integrated Circuits, conexión entre chips) utiliza dos líneas de comunicación bidireccionales, llamadas bus de datos en serie, para transferir datos. SDA (datos en serie) y autobús de reloj SCL (reloj serie). También hay dos líneas eléctricas. Los buses SDA y SCL se suben al riel de alimentación a través de resistencias.

Hay al menos uno en la web. dispositivo maestro, que inicia la transferencia de datos y genera señales de sincronización. La red también tiene dispositivos esclavos, que transmiten datos a petición del presentador. Cada dispositivo esclavo tiene una dirección única en la que el maestro se dirige a él. La dirección del dispositivo se indica en el pasaporte (hoja de datos). Se pueden conectar hasta 127 dispositivos a un bus I2C, incluidos varios maestros. Los dispositivos se pueden conectar al bus durante el funcionamiento, es decir, admite conexión en caliente.

Veamos el diagrama de tiempo de intercambio I2C. Hay varias opciones diferentes, considere una de las comunes. Usemos un analizador lógico conectado a los buses SCL y SDA.

El maestro inicia el intercambio. Para ello, empieza generando pulsos de reloj y los envía por la línea SCL en un pack de 9 piezas. Al mismo tiempo, en la línea de datos SDA, establece dirección del dispositivo, con los que es necesario establecer comunicación, que son cronometrados por los primeros 7 pulsos de reloj (de ahí la limitación en el rango de direcciones: 2 7 = 128 menos la dirección cero). El siguiente bit a enviar es código de operación(leer o escribir) y un bit más - bit de confirmación(ACK) que el esclavo ha aceptado la solicitud. Si no se recibe el bit de confirmación, el intercambio termina allí. O el maestro continúa enviando solicitudes repetidas.

Esto se ilustra en la siguiente figura, en el primer caso, por ejemplo, desconectaremos el dispositivo esclavo del bus. Se puede ver que el maestro está tratando de comunicarse con el dispositivo con la dirección 0x27, pero no recibe un reconocimiento (NAK). El intercambio termina.

Ahora conectemos el dispositivo esclavo al bus I2C y repitamos la operación. La situación ha cambiado. El primer paquete con la dirección recibió un reconocimiento (ACK) del esclavo. El intercambio continuó. La información también se transmite en paquetes de 9 bits, pero ahora se ocupan 8 bits datos y 1 bit - bit de confirmación el esclavo recibe cada byte de datos. Si en algún momento la conexión se interrumpe y el bit de reconocimiento no llega, el maestro dejará de transmitir.

2 implementación I2C en arduino

Arduino usa dos puertos para trabajar en la interfaz I2C. Por ejemplo, en Arduino UNO y Arduino Nano, el puerto analógico A4 corresponde a SDA, el puerto analógico A5 corresponde a SCL.

Para otros modelos de placa, la asignación de pines es la siguiente:

3 Biblioteca "Alambre" para trabajar con la CII

Para facilitar el intercambio de datos con dispositivos a través del bus I2C, se ha escrito una biblioteca estándar para Arduino. Cable. Tiene las siguientes características:

Función	Objetivo
comenzar (dirección)	inicialización de la biblioteca y conexión al bus I2C; si no se especifica la dirección, el dispositivo conectado se considera el maestro; se utiliza direccionamiento de 7 bits;
solicitud de()	utilizado por el maestro para solicitar una cierta cantidad de bytes del esclavo;
comenzarTransmisión(dirección)	inicio de la transferencia de datos al dispositivo esclavo en una dirección específica;
endTransmission()	terminación de la transmisión de datos al esclavo;
escribe()	registrar datos del esclavo en respuesta a una solicitud;
disponible()	devuelve el número de bytes de información disponibles para recibir del esclavo;
leer()	leer un byte transmitido del esclavo al maestro o del maestro al esclavo;
al recibir()	indica una función a llamar cuando el esclavo recibe una transmisión del maestro;
bajo pedido()	indica una función a llamar cuando el maestro recibe una transmisión del esclavo.

4 Conexión de un dispositivo I2C a arduino

Veamos cómo trabajar con el bus I2C usando Arduino.

Primero, armemos el circuito, como en la figura. Controlaremos la luminosidad del LED mediante un potenciómetro digital de 64 posiciones AD5171 (ver ficha técnica), que se conecta al bus I2C. La dirección por la que accederemos al potenciómetro es 0x2c (44 en decimal).

5 Gestión de dispositivos a través del autobús IIC

Considere los diagramas de intercambio de información con el potenciómetro digital AD5171 presentado en la hoja de datos:

Estamos interesados ​​aquí en el diagrama de escritura de datos en el registro. RDAC. Este registro se utiliza para controlar la resistencia del potenciómetro.

Abramos el boceto de los ejemplos de la biblioteca "Wire": Archivo Muestras Cable digital_potenciómetro. Vamos a cargarlo en la memoria de Arduino.

#incluir // incluir el byte de la biblioteca "Wire" val = 0; //valor a pasar al potenciometro configuración vacía()( Alambre.begin(); // conectar al bus I2C como maestro } bucle vacío() ( Wire.beginTransmission(44); // iniciar la comunicación con el dispositivo con dirección I2C "44" (0x2C) Wire.write(byte(0x00)); // envía una instrucción de escritura al registro RDAC Wire.write(val); // establecer la posición del potenciómetro de 64 posiciones Wire.endTransmission(); // completa la transferencia I2C val++; // incrementa val en 1 if (val == 63) ( // cuando el potenciómetro alcanza su valor máximo val = 0; // reinicia val ) delay(500); }

Después de encender, verá cómo el brillo del LED aumenta cíclicamente y luego se apaga. En este caso, controlamos el potenciómetro usando Arduino a través del bus I2C.

¿Cómo ampliar la funcionalidad del sistema desarrollado basado en un microcontrolador? Sí, esta pregunta es de interés para muchos ingenieros de circuitos que trabajan en prototipos de dispositivos electrónicos. Sorprendentemente, un bus desarrollado por ingenieros de Philips hace más de 30 años permitirá agregar nuevos bloques al sistema sin cambiar el circuito.

Gracias a la interfaz I2C, puede convertir el microcontrolador en un simple constructor, al que puede conectar varios cientos de microcircuitos. Cabe señalar de inmediato que su número está limitado por la capacidad del bus de 400 pF, pero esta es una de las pocas desventajas de I2C.

Esquema de intercomunicación: así es como puede descifrar el nombre del autobús, que hoy en día se puede encontrar en casi todos los dispositivos electrónicos. Vale la pena señalar que Philips patentó una solución tan exitosa en términos prácticos y otros fabricantes duplicaron I2C con otros nombres.

Es este bus el que está instalado para comunicarse con el mundo exterior de pantallas, cámaras, teléfonos celulares. La cantidad de periféricos conectados a dispositivos que usan I2C generalmente es incontable. ¿Cuáles son los beneficios de una interfaz?

Principales ventajas y desventajas de I2C

I2C es un bus serial asimétrico para la comunicación entre circuitos integrados dentro de dispositivos electrónicos. Utiliza dos líneas de comunicación bidireccionales (SDA y SCL).

El bus consta de dos conductores y un microcontrolador es suficiente para controlar la interfaz. Sorprendentemente, tal simplicidad le permite apagar los microcircuitos durante la operación. Un filtro incorporado especial puede hacer frente a las ráfagas, lo que garantiza la seguridad de la información procesada.

Entre las desventajas de I2C, además de la capacidad limitada, está la complejidad de la programación y la dificultad para identificar una falla en una situación de bajo nivel.

Inicialmente, la velocidad del bus era de solo 100 kbps y solo se podían conectar 120 dispositivos. En los años 90, los estándares cambiaron y la tasa de transferencia de datos aumentó 4 veces y se hizo posible conectar hasta 1000 microcircuitos.

Sin embargo, la mayoría de los fabricantes de interfaces se quedan con 400 kbps con 120 dispositivos conectados.

Principio de conexión y funcionamiento

Los conductores del bus están conectados al positivo con resistencias de 1-10k, uno de los conductores es el bus de datos, el otro es el reloj. Tal esquema funciona de manera simple: hay un dispositivo maestro (microcontrolador) y varios dispositivos periféricos en la línea. Dado que las líneas están alimentadas con el positivo, es suficiente que el esclavo conectado (elemento esclavo) presione el cable contra el suelo y, por lo tanto, transmita 0.

Cuando el dispositivo periférico suelta el cable, a través del cable se transmite 1. Todo es elemental, pero si uno de los esclavos emitió 0 durante el trabajo conjunto, el resto de los dispositivos conectados al bus tendrán que esperar. El microcontrolador realiza el cronometraje y la transmisión, habiendo especificado previamente si la línea está libre. Para hacer esto, se transmite 1 a SCL y SDA, después de lo cual se crea una condición de inicio: se presiona la línea SDA cuando el valor de SCL es 1.

La siguiente etapa del trabajo es la transferencia de la dirección del dispositivo al que desea contactar.

Debe recordarse que los datos se leen cuando SCL = 1, y la transmisión avanza con el bit más significativo.

Los primeros 7 bits son la dirección del dispositivo, 8 son el comando para escribir (0) o leer (1).

El esclavo recibirá las ocho señales, presione la línea SDA en el noveno ciclo SCL si todo está claro para él. De lo contrario, se genera una señal de parada y los datos se transmiten de nuevo. Cuando se completa el trabajo, la línea SDA se libera, mientras que SCL no se toca.

Incluso si el chip conectado procesa la señal lentamente, aún mantendrá SCL.

Modo multimaestro

Se regulan los temas de democracia en los circuitos. Se basa en la capacidad del dispositivo maestro para controlar el resultado del trabajo. Es obligatorio verificar dos veces si la línea está liberada o no, si está liberada, entonces el maestro está liderando actualmente, si no, entonces algo más importante está manteniendo la línea. En este caso, debe esperar a que se encienda la luz y hacer su trabajo cuando aparezca.

Sin embargo, es muy posible que todos los maestros decidan hacer negocios al mismo tiempo. En este caso, el campeonato será para el maestro que primero inició el cronometraje y lo hizo rápidamente. Si dos dispositivos funcionan sobresincrónicamente, el que genera 0 un poco más rápido que el oponente ganará primero.

El módulo LCD I2C le permite conectar una pantalla de caracteres a la placa Arduino con solo dos cables de señal.

Componentes usados ​​(comprar en China):

. tabla de control

. Cables de conexión

Características técnicas principales:

Pantalla: Carácter 16x02 o 20x04
. Iluminación: Azul con caracteres blancos
. Contraste: ajustable por potenciómetro
. Tensión de alimentación: 5V
. Interfaz: I2C
. Dirección I2C: 0x27
. Dimensiones: 82 mm x 35 mm x 18 mm

Conexión a Arduino

El módulo está equipado con un conector de cuatro pines de 2,54 mm.

SCL: línea de reloj en serie (Reloj en serie)

ASD: línea de datos en serie (Serial DAta)

CCV: potencia "+"

TIERRA: "-" energía

Los pines responsables de la interfaz I2C en las placas Arduino basadas en diferentes controladores varían

Para trabajar con este módulo, debe instalar la biblioteca LiquidCrystal_I2C1602V1

Descargue, descomprima y colóquelo en la carpeta de bibliotecas en la carpeta Arduino. Si en el momento de agregar la biblioteca, el IDE de Arduino estaba abierto, reinicie el entorno.

Vayamos directamente al boceto. En este ejemplo, mostraremos el estándar "¡Hola, mundo!" y para la dirección de nuestra comunidad.

ejemplo de código:

#incluir #incluir LiquidCrystal_I2C lcd (0x27,16,2); /* Establecer la dirección y el tamaño de la pantalla. Cuando se utiliza un módulo LCD I2C con una pantalla de 20x04, no es necesario cambiar nada en el código, solo debe establecer la dimensión correcta */ vacío configuración() (lcd.init(); // Inicializar lcd LCD luz de fondo(); // enciende la luz de fondo // El cursor está al principio de la línea 1 lcd.print("¡Hola, mundo!"); // Mostrar texto lcd.setCursor (0, 1); // Coloca el cursor al principio de la línea 2 lcd.print("sitio"); // Mostrar texto) vacío círculo () { }

Creando tus propios símbolos

Descubrimos la salida de texto, las letras del alfabeto inglés están cosidas en la memoria del controlador dentro de la pantalla y no hay problemas con ellas. Pero, ¿qué hacer si el carácter deseado no está en la memoria del controlador?

No importa, el carácter requerido se puede hacer manualmente. Este método parcialmente, limitado a 7 caracteres, ayudará a resolver el problema de salida.

La celda, en las pantallas que estamos considerando, tiene una resolución de 5x8 píxeles. Toda la tarea de crear un símbolo se reduce a escribir una máscara de bit y colocar unos en ella en lugares donde los puntos deberían arder y los ceros donde no.

En el siguiente ejemplo, dibujemos una cara sonriente.

ejemplo de código:

// Probado en Arduino IDE 1.0.5 // Agrega las bibliotecas necesarias#incluir #incluir // Máscara de bits de símbolo de sonrisa byte sonrisa = ( B00010, B00001, B11001, B00001, B11001, B00001, B00010, ); LiquidCrystal_I2C lcd (0x27,20,4); // Establecer la dirección y el tamaño de la pantalla. vacío configuración() (lcd.init(); // Inicializar lcd LCD luz de fondo(); // enciende la luz de fondo // Crear el símbolo número 0 lcd.createChar(1, sonrisa); lcd.setCursor(0, 0); // Coloca el cursor al principio de la línea 1 lcd.imprimir("\1"); // Mostrar el emoticón (carácter número 1) - "\1") vacío círculo () { }

Programa para la creación fácil de símbolos

En los comentarios, un miembro de la comunidad dejó caer un enlace a un generador de personajes.