Pantalla de ruido Arduino TFT Rainbow: 5 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Creamos este proyecto de arcoíris utilizando varias técnicas de 'ruido', que crean efectos aleatorios controlados. Añadiendo algo de color, se podría producir un efecto de arco iris. Utiliza un Arduino Nano y una pantalla OLED de 128x128. Mostramos los efectos usando la biblioteca TFT. También usamos algunos componentes diversos, como una placa de pruebas y algunos cables.

Paso 1: cableado

La tarea más básica fue el cableado del OLED al Arduino. Conectamos GND y VCC a los respectivos buses en el tablero; SCL al pin digital 13; SDA al pin digital 11; RES al pin digital 8; DC al pin digital 9; CS al pin digital 10 y finalmente BL a 3.3V en el Arduino. Usando los pines 5v y GND del Arduino pudimos alimentar toda la placa de pruebas.

Paso 2: ruido suave

Después de inicializar los requisitos para la pantalla TFT. Para crear el efecto de ruido suave, primero necesitábamos una función de ruido básica. Esto devuelve un valor relativamente aleatorio entre 0 y 1 basado en los valores xey pasados. Es importante tener en cuenta que una computadora nunca puede producir un resultado verdaderamente aleatorio, y esta aleatoriedad se logra simplemente cambiando el número tanto como sea posible., de ahí los números muy grandes en la ecuación.

ruido flotante (int x, int y) {int n; n = x + y * 57; n + = (n << 13) ^ n; return (1.0 - ((n * ((n * n * 15731) + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0); }

Luego "suavizamos" el ruido con otra función. Esto se logra produciendo un valor basado no solo en el resultado de la coordenada pasada a la función, sino también en las coordenadas circundantes. Como resultado de esto, las coordenadas cercanas entre sí producen un valor similar.

flotar smoothNoise (flotar x, flotar y) {flotar fractX = x - (int) x; flotar fractY = y - (int) y; int x1 = ((int) (x) + noiseWidth)% noiseWidth; int y1 = ((int) (y) + noiseHeight)% noiseHeight; int x2 = (x1 + noiseWidth - 1)% noiseWidth; int y2 = (y1 + noiseHeight - 1)% noiseHeight; valor flotante = 0.0f; valor + = fractX * fractY * ruido (x1, y1); valor + = (1 - fractX) * fractY * ruido (x2, y1); valor + = fractX * (1 - fractY) * ruido (x1, y2); valor + = (1 - fractX) * (1 - fractY) * ruido (x2, y2); valor de retorno; }

Paso 3: Efectos con ruido suave

Con esto creamos dos efectos. Para hacer esto, recorrimos cada píxel en el OLED y tomamos un valor de ruido aleatorio basado en las coordenadas xey de estos píxeles. El primero de estos efectos lo producimos utilizando el valor generado para elegir un color y coloreamos ese píxel con el color mencionado anteriormente. El segundo efecto se produjo de manera similar, pero también multiplicamos el color por el valor de ruido generado. Esto le dio al patrón un efecto más sombreado. El código utilizado se muestra a continuación:

void Noise2n3 (bool Ruidoso) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; if (Ruidoso) setNoisyColour (colores [absNoise], ruido); else setBlockColour (colores [ruido abs]); TFTscreen.point (x, y); }}} void setNoisyColour (Color de color, ruido flotante) {TFTscreen.stroke (color.red * ruido, color.green * ruido, colour.blue * ruido); } void setBlockColour (Color de color) {TFTscreen.stroke (colour.red, colour.green, colour.blue); }

Paso 4: efectos de degradado aleatorio

Hay dos efectos que producen un gradiente aleatorio. El primer efecto coloca los píxeles en relación con su color rgb, generando lentamente un patrón de degradado en la pantalla. El segundo usa los mismos píxeles de colores que el primero, pero los coloca en un orden fijo, creando un degradado diagonal a lo largo de la pantalla.

Aquí está el primero (basado en los colores):

Void Noise1 () {for (int z = 0; z <3; z ++) {TFTscreen.background (0, 0, 0); int CurrentColour [3] [3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = CurrentColour [z] [0]; G = CurrentColour [z] [1]; B = CurrentColour [z] [2]; para (int x = 0; x <128; x ++) {para (int y = 0; y <128; y ++) {int R_Inferior = R - ((x + y) / 4); si (R_Lower = 255) {R_Higher = 254; } int R_Offset = aleatorio (R_Lower, R_Higher); int G_Inferior = G - ((x + y) / 4); si (G_Lower = 255) {G_Higher = 254; } int G_Offset = aleatorio (G_Lower, G_Higher); int B_Inferior = B - ((x + y) / 4); si (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); si (B_Higher> = 255) {B_Higher = 254; } int B_Offset = aleatorio (B_Lower, B_Higher); int mult = 2; si (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point ((R_Offset * (B_Offset / 32)), (G_Offset * (B_Offset / 32))); TFTscreen.point ((G_Offset * (B_Offset / 32)), (R_Offset * (B_Offset / 32))); TFTscreen.point ((B_Offset * (G_Offset / 32)), (R_Offset * (G_Offset / 32))); }}}}

Y el segundo (el efecto más ordenado):

Void Noise4 () {for (int z = 0; z <3; z ++) {TFTscreen.background (0, 0, 0); int CurrentColour [3] [3] = {{64, 35, 26}, {24, 64, 34}, {20, 18, 64}}; R = CurrentColour [z] [0]; G = CurrentColour [z] [1]; B = CurrentColour [z] [2]; para (int x = 0; x <128; x ++) {para (int y = 0; y <128; y ++) {int R_Lower = R - ((x + y) / 4); si (R_Lower = 255) {R_Higher = 254; } int R_Offset = aleatorio (R_Lower, R_Higher); int G_Inferior = G - ((x + y) / 4); si (G_Lower = 255) {G_Higher = 254; } int G_Offset = aleatorio (G_Lower, G_Higher); int B_Inferior = B - ((x + y) / 4); si (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); si (B_Higher> = 255) {B_Higher = 254; } int B_Offset = aleatorio (B_Lower, B_Higher); int mult = 2; si (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

Paso 5: el resultado final

Al final, combinamos estos efectos en una especie de "presentación de diapositivas" de arco iris. Para lograr esto, simplemente llamamos a cada función después de la otra en un ciclo while:

while (verdadero) {Noise2n3 (falso); Noise2n3 (verdadero); TFTscreen.background (0, 0, 0); Ruido1 (); Noise4 (); }