Tela de ruído do Arduino TFT Rainbow: 5 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Criamos este projeto de arco-íris usando várias técnicas de 'ruído', que criam efeitos aleatórios controlados. Ao adicionar alguma cor, um efeito de arco-íris pode ser produzido. Ele usa um Arduino Nano e um display OLED de 128x128. Exibimos os efeitos usando a biblioteca TFT. Também usamos alguns componentes diversos, como uma placa de pão e alguns fios.

Etapa 1: Fiação

A tarefa mais básica era conectar o OLED ao Arduino. Conectamos o GND e o VCC aos respectivos barramentos na placa de pão; SCL para pino digital 13; SDA para pino digital 11; RES para pino digital 8; DC para pino digital 9; CS para pino digital 10 e finalmente BL para 3,3 V no Arduino. Usando os pinos 5v e GND do Arduino, fomos capazes de alimentar toda a placa bread.

Etapa 2: ruído suave

Após inicializar os requisitos para o display TFT. Para criar o efeito de ruído suave, primeiro precisamos de uma função de ruído básica. Isso retorna um valor relativamente aleatório entre 0 e 1 com base nos valores xey passados. É importante notar que um computador nunca pode produzir um resultado verdadeiramente aleatório, e essa aleatoriedade é meramente alcançada mudando o número tanto quanto possível, daí os números muito grandes na equação.

ruído flutuante (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); }

Em seguida, 'suavizamos' o ruído com outra função. Isso é obtido produzindo um valor baseado não apenas no resultado da coordenada passada para a função, mas também nas coordenadas circundantes. Como resultado disso, as coordenadas próximas umas das outras produzem um valor semelhante.

float smoothNoise (float x, float y) {float fractX = x - (int) x; float 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 flutuante = 0,0f; valor + = ruído fractX * fractY * (x1, y1); valor + = (1 - fractX) * fractY * ruído (x2, y1); valor + = fractX * (1 - fractY) * ruído (x1, y2); valor + = (1 - fractX) * (1 - fractY) * ruído (x2, y2); valor de retorno; }

Etapa 3: efeitos usando ruído suave

Com isso criamos dois efeitos. Para fazer isso, percorremos cada pixel no OLED e pegamos um valor de ruído aleatório com base nas coordenadas xey desses pixels. O primeiro desses efeitos foi produzido usando o valor gerado para escolher uma cor e colorir esse pixel com a cor mencionada. O segundo efeito foi produzido de forma semelhante, mas também multiplicamos a cor pelo valor do ruído gerado. Isso deu ao padrão um efeito mais sombreado. O código usado é mostrado abaixo:

void Noise2n3 (bool Noisy) {for (int y = 0; y <noiseHeight; y ++) {for (int x = 0; x 8) absNoise = 8; if (Noisy) setNoisyColour (cores [absNoise], ruído); else setBlockColour (cores [absNoise]); TFTscreen.point (x, y); }}} void setNoisyColour (Color color, float noise) {TFTscreen.stroke (colour.red * noise, colour.green * noise, colour.blue * noise); } void setBlockColour (Color color) {TFTscreen.stroke (colour.red, colour.green, colour.blue); }

Etapa 4: efeitos de gradiente aleatório

Existem dois efeitos que produzem um gradiente aleatório. O primeiro efeito posiciona os pixels em relação à sua cor rgb, renderizando lentamente um padrão de gradiente na tela. O segundo usa os mesmos pixels coloridos do primeiro, mas os coloca em uma ordem fixa, criando um gradiente diagonal ao longo da tela.

Aqui está o primeiro (com base nas cores):

void Noise1 () {para (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]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x + y) / 4); if (R_Lower = 255) {R_Higher = 254; } int R_Offset = aleatório (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); if (G_Lower = 255) {G_Higher = 254; } int G_Offset = aleatório (G_Lower, G_Higher); int B_ Inferior = B - ((x + y) / 4); if (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); if (B_Higher> = 255) {B_Higher = 254; } int B_Offset = aleatório (B_Lower, B_Higher); int mult = 2; if (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))); }}}}

E o segundo (o efeito mais ordenado):

void Noise4 () {para (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]; for (int x = 0; x <128; x ++) {for (int y = 0; y <128; y ++) {int R_Lower = R - ((x + y) / 4); if (R_Lower = 255) {R_Higher = 254; } int R_Offset = aleatório (R_Lower, R_Higher); int G_Lower = G - ((x + y) / 4); if (G_Lower = 255) {G_Higher = 254; } int G_Offset = aleatório (G_Lower, G_Higher); int B_ Inferior = B - ((x + y) / 4); if (B_Lower <1) {B_Lower = 0; } int B_Higher = B + ((x + y) / 4); if (B_Higher> = 255) {B_Higher = 254; } int B_Offset = aleatório (B_Lower, B_Higher); int mult = 2; if (z == 1) mult = 1; TFTscreen.stroke (R_Offset * mult, G_Offset * mult, B_Offset * mult); TFTscreen.point (x, y); }}}}

Etapa 5: o resultado final

No final, combinamos esses efeitos em uma espécie de 'apresentação de slides' de arco-íris. Para conseguir isso, simplesmente chamamos cada função após a outra em um loop while:

enquanto (verdadeiro) {Noise2n3 (falso); Noise2n3 (verdadeiro); TFTscreen.background (0, 0, 0); Noise1 (); Noise4 (); }