https://jorgechac.blogspot.com: mayo 2021

jueves, 20 de mayo de 2021

Nueva Placa Arduino Nano RP2040 Connect

Bienvenido a mi blog, hoy hablaremos un poco de la nueva placa Arduino Nano RP2040 Connect, la cuál ha sido lanzada por la gente de Arduino un poco mas de 4 meses después del lanzamiento de la Raspberry Pi Pico, esta nueva placa cuenta con un chip microcontrolador ARM Cortex M0+ de doble núcleo de 32 bits, con una frecuencia de reloj de 133 MHz y es lo suficientemente potente como para ejecutar algoritmos de aprendizaje máquina desarrollados con TensorFlow Lite. Este SoC es aún joven, pero está demostrando ser increíblemente popular y será emocionante ver cómo reacciona la comunidad Arduino. Solo pueden imaginar lo que ustedes lograrán con las características adicionales de la nueva placa Nano RP2040 Connect.

A diferencia de la Raspberry Pi Pico, la Arduino Nano RP2040 Connect tiene 30 pines GPIO en lugar de los 40 de la pico. Así que fue una elección fácil para Arduino poner un RP2040 en el núcleo de una nueva placa. Se sienten tan convencidos de la excelencia de este nuevo chip que saben que merecía una placa Nano Potente y Premium. Lo primero y más importante es la inclusión del módulo de radio u-blox NINA-W102 WiFi (802.11 b/g/n) Bluetooth y BLE 4.2 <el ESP-32 también contiene el mismo chip para soporte WiFi> Los usuarios de nano probablemente ya estén bastante familiarizados con este excelente módulo. Junto con un sensor de movimiento IMU de seis ejes con capacidad de aprendizaje automático, un micrófono integrado para activación de sonido y voz, un LED RGB y un montón de pines GPIO multifunción. Adicional a estos elementos la tarjeta integra un co-procesador criptográfico de bajo consumo ATECC608A (cortesía de microchip) con el que se pueden establecer distintos protocolos de encriptación y desencriptación para establecer comunicaciones seguras y que lo hemos visto en las placas de la familia MKR, este nuevo Arduino es el sueño del creador de proyectos hecho realidad. Y todo en un tablero tan pequeño (solo falto incluirle un modulo GSM como el SIM800L).

Características Técnicas Principales:

Board	Nano RP2040 Connect with Headers
Board	SKU: ABX00053
Microcontroller	Raspberry Pi RP2040
USB connector	Micro USB
Pins	Built-in LED pin	13
	Digital I/O Pins	20
	Analog Input Pins	8
	PWM pins	20 (Except A6, A7)
	External interrupts	20 (Except A6, A7)
Connectivity	Wi-Fi	Nina W102 uBlox module
	Bluetooth	Nina W102 uBlox module
	Secure element	ATECC608A-MAHDA-T Crypto IC
Sensors	IMU	LSM6DSOXTR (6-axis)
Sensors	Microphone	MP34DT05
Communication	UART	Yes
	I2C	Yes
	SPI	Yes
Power	Circuit operating voltage	3.3V
	Input Voltage (VIN)	5-21V
	DC Current per I/O pin	4 mA
Clock speed	Processor	133 MHz
Memory	AT25SF128A-MHB-T	16MB Flash IC
Memory	Nina W102 uBlox module	448 KB ROM, 520KB SRAM, 16MB Flash
Dimensions	Weight	6 g
	Width	18 mm
	Length	45 mm

El Arduino Nano RP2040 Connect es "Compatible con Raspberry Pi Pico", lo que significa que no solo tiene soporte para todo el ecosistema de software RP2040, sino también soporte completo para MicroPyhton. Incluso hay una licencia OpenMV gratuita incluida, para cualquier proyecto de visión artificial. Al mismo tiempo, la placa es compatible con el lenguaje de programación Arduino, el IDE 2.0 y todas las bibliotecas que lo acompañan. (Aunque la version del IDE 2.0 de Arduino, al momento de escribir este post aun esta en beta, la version 1.8.19 ya es estable y esta disponible para su descarga gratuita aqui) Finalmente, se puede programar y operar directamente desde un navegador y es totalmente compatible con Arduino Cloud y la aplicación de teléfonos móviles inteligente Arduino IoT Remote. Debido a que el Nano RP2040 Connect es un dispositivo conectado, esto abre todo tipo de posibilidades. Si tiene una señal WiFi, puede hacer todo como si estuvieras conectado por USB.

Soporte de Software y Actualizaciones

Hace un par de semanas se actualizo el Arduino Mbed Core oficial para brindar soporte nativo RP2040. La naturaleza plug-and-play del Arduino Core significa que puede usar bocetos existentes que hizo para, digamos, un Nano 33 BLE Sense en su nuevo Nano RP2040 Connect. Por lo tanto, puede tener este pequeño caballo de batalla en funcionamiento en cuestión de minutos, si ya ha estado trabajando en algunos bocetos de proyectos. Además, es compatible con todo el ecosistema de software RP2040, por lo que si se trata de una actualización para una placa RP2040 existente, ya está listo.

Compra Aquí Tu Nueva Arduino Nano RP2040 Connect por solo $25.50 dólares

Preguntas:

¿El Nano RP2040 tiene pines I2C?/¿Puedo utilizar la comunicación I2C con el Nano RP2040?

- Pines I2C: los pines A4 y A5 tienen un pull up interno y, por defecto, se utilizan como bus I2C, por lo que no se recomienda su uso como entradas analógicas.

- Voltaje de funcionamiento: el voltaje de funcionamiento para Nano RP2040 Connect es de 3,3 V

¿El Nano RP2040 tiene pines PWM?

- PWM: todos los pines excepto A6 y A7 están disponibles para PWM.

¿Cómo puedo utilizar el LED RGB integrado?

- RGB: El LED RGB se conecta a través del módulo Wi-Fi, por lo que se requiere incluir la biblioteca WiFiNINA para usarlo.

<<< Descarga aqui el datasheet completo de la nueva placa

Aquí tenemos el "Interactive Board Viewer" del Arduino NANO RP2040 Connect donde podemos ver la vista del esquemático original, la vista PCB y el visor 3D de la placa (cortesía: Altium 365 Viewer):

También se cuenta con Fritzing Part de la nueva placa Arduino Nano RP2040 Connect:

Dimensiones Reales de la Arduino NANO RP2040 Connect en mm

Finalmente tenemos la parte Arduino NANO RP2040 Connect para Proteus Design Suite, el cual es un software de automatización de diseño electrónico, desarrollado por Labcenter Electronics Ltd, para lo cual deberás descargar la librería y copiarla a la ruta de instalación del programa C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\DATA\LIBRARY.

A dicha parte también deberás asignar un footprint y anexarle el modelo 3D en un archivo .stp

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

Recuerda que en https://jorgechac.blogspot.com nos dedicamos a construir una electrónica mejor! y apoyamos el proyecto CTC GO! (Creative Technologies in the Classroom) que es un programa de educación steam personalizable.

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

lunes, 3 de mayo de 2021

Manejo básico de una pantalla OLED I2C con Arduino

Bienvenido a mi blog, hoy hablaremos un poco del manejo básico de una pantalla OLED I²C con nuestro Arduino UNO Rev3, Arduino es una plataforma de creación de electrónica de código abierto, la cual está basada en hardware y software libre, flexible y fácil de utilizar para los creadores o desarrolladores, para hacerlo, utiliza el lenguaje de programación Arduino (basado en Wiring) y el Software Arduino IDE (basado en Processing). Recordemos que Arduino es un proyecto, un ecosistema y no solo un modelo concreto de placa.

No es el objetivo de este articulo abordar toda la teoría y la historia de las pantallas OLED, así que hare un breve resumen acotando que las pantallas OLED, Organic Light-Emitting Diode, que traducido sería diodo orgánico de emisión de luz, se trata de pantallas capaces de consumir muy poca energía, son muy delgadas, se comunican por protocolo I²C o SPI y producen una imagen más brillante y nítida que una pantalla LCD. Una de las ventajas de las pantallas OLED con respecto a las pantallas LCD que vimos anteriormente, es que no requieren de una luz de fondo (backligth) ni de filtros. Esto hace que las pantallas OLED sean más fáciles de fabricar y mucho más finas. A parte pueden ser flexibles y transparentes.

Las pantallas OLED necesitan un driver o controlador, normalmente viene todo ensamblado en un mismo módulo. Así es como las encontrarás en las tiendas de electrónica. Sin embargo, debe quedar claro que en ese módulo está la pantalla OLED, el controlador y toda la electrónica necesaria para que funcione correctamente.

Utilizaremos el pin +5Vcc (también funciona con el +3.3v) del Arduino UNO Rev3 para alimentar la OLED con los +5 voltios del puerto USB de la PC (Vcc), el pin GND de la placa Arduino ira a GND de la OLED, el pin SDA (A4) del Arduino ira a SDA de la OLED y el pin SCL (A5) del Arduino ira a SCL de la OLED, como podemos ver en el siguiente esquemático:

Normalmente estos módulos utilizan un controlador bastante conocido que se llama SSD1306. Pero pueden utilizar otro tipo de controladores. Dicho SSD1306 se trata de un potente controlador OLED CMOS. Básicamente lo que hace este SSD1306, es comunicarse con el microcontrolador para obtener los datos y enviarlos a la pantalla OLED para que dibuje esos datos. La comunicación entre el SSD1306 y el microcontrolador, ya sea un Arduino o un ESP32 o una Raspberry Pi Pico, por ejemplo, se realiza mediante protocolo SPI o I2C. Generalmente, la comunicación SPI es más rápida que la comunicación I2C. Por el contrario, la comunicación SPI requiere de más pines que la comunicación I2C. Al final una cosa compensa a la otra. Puedes elegir una comunicación más rápida en detrimento del número de pines, o puedes elegir liberar más pines en detrimento de la velocidad. No deja de ser una elección que depende de lo que estés diseñando y la exigencia que requiera el desarrollo hardware.

Como ya lo mencione, se puede alimentar un módulo de pantalla OLED que utilice un controlador SSD1306 con una alimentación de +3,3V o de +5V. Lo que quiere decir que es compatible tanto para ESP8266, ESP32, Arduino, así como para Raspberry Pi Pico. Inicialmente deberemos descargar alguna librería que sea capaz de controlar la OLED vía I²C directamente con Wiring, para este caso usaremos las librerías "Adafruit_SSD1306", "Adafruit-GFX-Library" "LCDGFX" "OLED_I2C.zip" Lo vamos a hacer como siempre lo hacemos cuando queremos instalar una librería de Arduino. Abrimos el gestor de librerías y buscamos SSD1306. Debemos instalar la librería de Adafruit SSD1306:

Si haces click en el botón de Install instalará la librería solicitada, mismo procedimiento realizamos con la "Adafruit-GFX-Library", para la "OLED_I2C.zip" la podemos descargar gratis desde este repositorio en github.

La librería "Adafruit GFX" es la librería gráfica es decir, la que se encarga de dibujar en la pantalla OLED, proporciona una serie de gráficos primitivos como puntos, líneas, rectángulos, círculos, etc. La librería "Adafruit_SSD1306" es la librería específica para las pantallas OLED basadas en el controlador SSD1306. Funciona tanto para pantallas I²C como SPI. Las dos librerías ofrecen multitud de funciones y se complementan entre si.

Una vez montado el circuito e instaladas las tres librerías ya se puede empezar a programar en Arduino (basado en Wiring) y el Software Arduino IDE (basado en Processing).

Vamos a empezar por un ejercicio muy sencillo que muestre la resolución de nuestra pantalla OLED I²C 0.96" con Arduino UNO Rev3.

Que muestre un mensaje inicial que diga "PRUEBA OLED 128x64" por 5 segundos y realice un barrido horizontal y vertical simultaneo para averiguar de que resolución es la pantalla OLED conectada y repita ese ciclo indefinidamente:

#include <OLED_I2C.h>

#include <math.h>

OLED myOLED(SDA, SCL, 8);

extern uint8_t SmallFont[]; // Selecciono el tamaño de fuente (Small o Big)

extern uint8_t MediumNumbers[]; // Selecciono el tamaño de fuente para los numeros

void setup()

{

myOLED.begin(); //inicializa el display OLED

myOLED.setFont(SmallFont); //seteo el tamaño de la fuente

myOLED.print("PRUEBA OLED 128x64", CENTER, 0); //imprime la frase entre comillas

myOLED.update(); // actualiza la pantalla haciendo lo anterior

delay(5000); // visualiza el mensaje estatico por 5 segundos (solo la primera vez)

myOLED.clrScr(); // borra la pantalla

}

void loop ()

{

int i=0;

int j=0;

for(i=0;i<64;i++){

myOLED.printNumI(j,j-12,20); //imprime el valor de la entrada analogica(valor,x,y)

myOLED.printNumI(i,1,i-8); //imprime el valor de la entrada analogica

myOLED.drawLine(1,i,30,i); //dibuja una recta entre (X0,Y0) y (X1,Y1) seteando (X0,Y0,X1,Y1)

myOLED.drawLine(j,10,j,30); //dibuja una recta entre (X0,Y0) y (X1,Y1) seteando (X0,Y0,X1,Y1)

myOLED.update(); //actualiza la pantalla

delay(100);

myOLED.clrScr(); //borra la pantalla

j=j+1;

}

delay(500);

for(j=63;j<128;j++){

myOLED.printNumI(j,j-17,20); // imprime el valor de la entrada analogica(valor,x,y)

myOLED.printNumI(63,1,i-8); // imprime el valor de la entrada analogica

myOLED.drawLine(1,63,30,63); //dibuja una recta entre (X0,Y0) y (X1,Y1) seteando (X0,Y0,X1,Y1)

myOLED.drawLine(j,10,j,30); //dibuja una recta entre (X0,Y0) y (X1,Y1) seteando (X0,Y0,X1,Y1)

myOLED.update(); //actualiza la pantalla

delay(100);

myOLED.clrScr(); //borra la pantalla

}

myOLED.printNumI(j,j-21,20); //imprime el valor de la entrada analogica(valor,x,y)

delay(3000);

}

Por ultimo vamos a visualizar una imagen en nuestra pantalla OLED, mostraremos un mensaje inicial que diga "PRUEBA OLED 128x64" por 5 segundos y seguidamente visualizaremos una imagen intermitente e indefinidamente, la cual corresponde al logotipo de Arduino como prueba:

#include <OLED_I2C.h>

OLED control_OLED(SDA, SCL, 8);

extern uint8_t SmallFont[]; //Selecciono el tamaño de fuente (Small o Big)

extern uint8_t MediumNumbers[]; //Selecciono el tamaño de fuente para los numeros

const uint8_t IDE_Arduino_20[] PROGMEM={

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0010 (16) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x0F, 0x07, 0x03, 0x03, 0x03, 0x01, // 0x0020 (32) pixels

0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x03, // 0x0030 (48) pixels

0x03, 0x03, 0x07, 0x07, 0x0F, 0x1F, 0x3F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0040 (64) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x1F, 0x1F, 0x0F, 0x07, 0x07, 0x03, 0x03, 0x03, 0x01, // 0x0050 (80) pixels

0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x03, // 0x0060 (96) pixels

0x03, 0x07, 0x07, 0x0F, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, 0xF3, 0xF3, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0070 (112) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0080 (128) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0090 (144) pixels

0xFF, 0x3F, 0x0F, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xF0, 0xF0, 0xF8, 0xFC, 0xFE, // 0x00A0 (160) pixels

0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFC, // 0x00B0 (176) pixels

0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x0F, 0x1F, 0x3F, 0x3F, // 0x00C0 (192) pixels

0x1F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, // 0x00D0 (208) pixels

0xFE, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFC, 0xFC, // 0x00E0 (224) pixels

0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0F, 0x7F, 0xFF, 0xFF, 0xFF, // 0x00F0 (240) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0100 (256) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0110 (272) pixels

0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0120 (288) pixels

0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0xFF, // 0x0130 (304) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0140 (320) pixels

0x00, 0x00, 0x00, 0x20, 0xF0, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0150 (336) pixels

0x0F, 0x0F, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0160 (352) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, // 0x0170 (368) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0180 (384) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0190 (400) pixels

0xF8, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x1F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x01A0 (416) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x01B0 (432) pixels

0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xC0, // 0x01C0 (448) pixels

0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x01D0 (464) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xF0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x01E0 (480) pixels

0xFF, 0xFF, 0xFF, 0x3F, 0x1F, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFE, 0xFF, 0xFF, // 0x01F0 (496) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0200 (512) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0210 (528) pixels

0xFF, 0xFF, 0xFF, 0xFC, 0xF8, 0xE0, 0xC0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x07, // 0x0220 (544) pixels

0x0F, 0x0F, 0x0F, 0x0F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, // 0x0230 (560) pixels

0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0240 (576) pixels

0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x07, 0x0F, // 0x0250 (592) pixels

0x0F, 0x0F, 0x0F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x03, // 0x0260 (608) pixels

0x03, 0x01, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0270 (624) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0280 (640) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0290 (656) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFC, 0xFC, 0xF8, 0xF8, // 0x02A0 (672) pixels

0xF8, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF8, 0xF8, // 0x02B0 (688) pixels

0xF8, 0xFC, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x02C0 (704) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFC, 0xFC, 0xF8, 0xF8, 0xF8, // 0x02D0 (720) pixels

0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF8, 0xF8, 0xF8, // 0x02E0 (736) pixels

0xFC, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x02F0 (752) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0300 (768) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0310 (784) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x01, 0x81, 0xE1, 0xC1, 0x01, 0x0F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0320 (800) pixels

0x01, 0x01, 0x01, 0x79, 0x79, 0x79, 0x31, 0x01, 0x03, 0x87, 0xFF, 0xFF, 0xFF, 0x01, 0x01, 0x19, // 0x0330 (816) pixels

0xF9, 0xF9, 0xF9, 0xF9, 0xF1, 0x03, 0x03, 0x0F, 0xFF, 0xFF, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0xFF, // 0x0340 (832) pixels

0xFF, 0xFF, 0xFD, 0x01, 0x01, 0xFF, 0xFF, 0xFF, 0xF9, 0xF9, 0xF9, 0xF9, 0x01, 0x01, 0xF9, 0xF9, // 0x0350 (848) pixels

0xF9, 0xF9, 0xFF, 0xFF, 0xFF, 0x01, 0x01, 0x81, 0x81, 0x07, 0x1F, 0x7F, 0xFF, 0xFD, 0x01, 0x01, // 0x0360 (864) pixels

0xFF, 0xFF, 0x0F, 0x03, 0xC1, 0xF1, 0xF9, 0xF8, 0xF8, 0xF9, 0xE1, 0x03, 0x07, 0x1F, 0xFF, 0xFF, // 0x0370 (880) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0380 (896) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0390 (912) pixels

0xFF, 0x7F, 0x07, 0x00, 0xE0, 0xF0, 0xF3, 0xF3, 0xF3, 0xF0, 0xE0, 0x80, 0x83, 0x9F, 0xFF, 0xFF, // 0x03A0 (928) pixels

0x80, 0x80, 0x80, 0xFE, 0xFC, 0xF8, 0xE0, 0x81, 0x07, 0x1F, 0x7F, 0xFF, 0xFF, 0x80, 0x80, 0x90, // 0x03B0 (944) pixels

0x9F, 0x9F, 0x9F, 0x9F, 0x8F, 0xC0, 0xE0, 0xF0, 0xFF, 0xFF, 0xE0, 0x80, 0x80, 0x9F, 0x1F, 0x3F, // 0x03C0 (960) pixels

0x3F, 0x9F, 0x87, 0x80, 0xE0, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x1F, 0x1F, // 0x03D0 (976) pixels

0x1F, 0x1F, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFE, 0xF8, 0xC0, 0x83, 0x03, 0x00, 0x00, // 0x03E0 (992) pixels

0xFF, 0xFF, 0xE0, 0xC0, 0x83, 0x8F, 0x1F, 0x1F, 0x1F, 0x9F, 0x87, 0xC0, 0xE0, 0xF8, 0xFF, 0xFF, // 0x03F0 (1008) pixels

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x0400 (1024) pixels

};

void setup()

{

control_OLED.begin(); // Inicializo la OLED

control_OLED.setFont(SmallFont); //seteo el tamaño de la fuente

control_OLED.print("PRUEBA OLED 128x64", CENTER, 0); //imprime la frase entre comillas

control_OLED.update(); // actualiza la pantalla haciendo lo anterior

delay(5000); // visualiza el mensaje estatico por 5 segundos (solo la primera vez)

control_OLED.clrScr(); // borra la pantalla

}

void loop () {

control_OLED.invert(false); // Invertir colores FALSO

control_OLED.clrScr(); // borrar toda la pantalla

control_OLED.drawBitmap(0, 0, IDE_Arduino_20, 128, 64); // mostrar la imagen importada en OLED 128x64

control_OLED.update(); // Imprime en pantalla OLED

delay(700); // retardo

control_OLED.invert(true); // Invertir colores FALSO

control_OLED.update(); // Imprime en pantalla OLED

delay(700); // retardo, mostrar la imagen durante 700 mseg

}

La librería y los códigos .ino de los ejemplos anteriores los puedes descargar gratis del repositorio de github que mencione mas arriba. También tengo los mismos códigos publicados en:

Prueba_resolucion_OLED.ino

https://create.arduino.cc/editor/jorgechac/28219937-e44b-4390-9c58-c63fc6fe9b72/preview

Imagen_en_OLED.ino

https://create.arduino.cc/editor/jorgechac/d0ea4c7d-c9a1-4d71-80fe-bd7012d746a2/preview

Finalmente recordemos que este es solo el manejo básico de una pantalla OLED, a medida que avancemos iremos añadiendo más funciones y aumentando la complejidad.

Leer Primero

Como se utiliza este blog?

jueves, 20 de mayo de 2021

Nueva Placa Arduino Nano RP2040 Connect

lunes, 3 de mayo de 2021

Manejo básico de una pantalla OLED I2C con Arduino