Yaratıcılık Bölümü'nden haberler | Haberler Online

semaver

semaver

New member


  1. Yaratıcılık Departmanından Haberler

Son bölümlerde, teknik olarak WS2812B bloklarına dayanan aydınlatma oyunlarıyla karşılaştık. Yeni sonuçları yaratıcı tasarım çalışmaları için kullanmanın zamanı geldi.



Bu yazıda, iki yaratıcı proje programda, bir yandan ev için bir aksesuar olarak bir tasarımcı saati, diğer yandan bir RGB renk sensörü ve bir LED şerit kombinasyonu.

Tasarımla buluşuyor


Saat tasarımcımız, son iki bölümde zaten kullandığımız tuğlaları yönetiyor.

  • Dev adofruit halkası veya alternatif olarak 60 LED'li 1 m şerit gibi 60 WS2812B LED'lik bir halka.
  • LED'leri parlatmak için bir güç kaynağı.
  • Seçtiğiniz bir Arduino masası!
  • Güç şeridi/LED halka gücünün anot ve katodu arasında konumlandırılmış 1000 uF olan bir elektrolitik kapasitör.
  • Arduino'nun dijital çıkışı 6 ve piksel verilerinin girişi arasında 470 Ω direnç.



Devre zaten denedi



Devre zaten denedi



Saatimizde olduğu gibi, elbette 60 LED'i saat, dakika, ikinci ve 12:00 için işaretler kullanıyoruz. (Kuzey), Sabahın 3'ü (doğu), 6:00 (Güney), 9:00 (Batı). Saatler, dakikalar ve saniyeler farklı renkte dolaşan piksellerden oluşur. Ayrıca, önceden paketlenmiş bir renge sahip hafif piksel olarak belirtilen işaretleri de gösteriyoruz.

Bir sorun, saatlik göstergeler ve dakikalar gibi farklı pozisyonların örtüşebilmesidir. Burada sadece “oluşturulmuş” renklerle çalışabiliriz. İlgilenen piksellere karşılık gelen hesaplanmış bir renk alır. Örneğin, Rosé meydana gelirse, aynı zamanda ikinci eller ve şimdi karşılık gelen pozisyonda vardır.



Daha Fazla Seçenekler


Programın kendisi tam olarak şok edici değil, hafif gıdalar ve aynı zamanda biraz iyileştirme veya genişleme potansiyeli içerir:

  • İlk günlere girmek zorunda kalmamak için devreye gerçek bir saat eklenmeniz önerilir. Listedeki kırmızı işaretli alana bakın.
  • ESP-01 WiFi kartı ile zamanı NTP sunucusu üzerinden senkronize edebiliriz.
  • Aydınlanmanın yoğunluğu günün saatine göre ayarlanabilir.
  • Harici bir yapılandırma kullanarak renk seçimi değişkenini oluşturabiliriz.
  • Ayarları rahat hale getirmek için IR uzaktan kumandasını kullanabiliriz.
  • Saat, farklı ellerin bağımsız olarak hareket ettiği eşmerkezli halkalar tarafından bir araya getirilebilir.
Eskiz'e bak


Programlama, projenin en basit kısmıdır, bu nedenle bir sonraki çizimde arama yapılması tavsiye edilir. Programlama blokları yoktur.


//////////////////////////////////////////////////////////////////
//
// Programmierung einer Designeruhr als Wandschmuck
// Grundlage ist ein LED-Streifen (WS2812B) oder ein Ring mit
// 60 LEDs
//
//////////////////////////////////////////////////////////////////
// Import der Neopixel-Bibliothek von Adafruit:
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif

// Anschluss der LEDs an Digitalausgang 6:
#define PIN 6

// Streifen/Ring initialisieren:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

// Position des Stundenzeigers:
uint8_t currentHour;
// Position des Minutenzeigers:
uint8_t currentMin;
// Position des Sekundenzeigers:
uint8_t currentSec;

// Initialisierung:
void setup() {
strip.begin(); // Streifen initialisieren
strip.show(); // Alle Pixel erst einmal aus



// Initiale Uhrzeit manuell einstellen
// Initialer Zustand der Uhrenanzeige bei Programmstart:
currentHour = 19; // Position wird modulo 12 berechnet
currentMin = 59;
currentSec = 40;
}

//////////////////////////////////////////////////////////////////
//
// Methode: colorPicker(Pixelnummer)
// Ergebnis: zusammengesetzte Farbe
// Zweck: Farbanteile einer LED berechnen
//
//////////////////////////////////////////////////////////////////
uint32_t colorPicker(uint8_t pos) {
const uint32_t hourColor = 0xD00000; // Stundenzeiger mit Rot
const uint32_t minColor = 0x00D000; // Minutenzeiger mit Grün
const uint32_t secColor = 0x0000D0; // Sekundenzeiger mit Blau
uint32_t result = 0;
// Bei Position in N, O, S, W Extra-Farbanteil für R, G, B hinzufügen:
if (pos % 15 == 0) result += 0x2F2F2F;
// Ist Minutenzeiger auf dieser Position,
// Grünanteil hinzufügen:
if (pos == currentMin) result += minColor;
// Ist Sekundenzeiger auf dieser Position,
// Blauanteil hinzufügen:
if (pos == currentSec) result += secColor;
// Ist Stundenzeiger auf dieser Position,
// Rotanteil hinzufügen:
if (pos == currentHour) result += hourColor;
// Resultierende Farbe zurück melden
return result;
}
//////////////////////////////////////////////////////////////////
//
// Methode: displayClock()
// Zweck: Für alle 60 Pixel Farbe errechnen,
// bei der LED entsprechend setzen,
// und darstellen
//
//////////////////////////////////////////////////////////////////
void displayClock() {

for (uint8_t pixno = 0; pixno < 60; pixno++)
strip.setPixelColor(pixno, colorPicker(pixno));
strip.show();
}

//////////////////////////////////////////////////////////////////
//
// Methode: incrementTimeBySecond
// Zweck: Berechnet neue Zeit nach einer Sekunde
//
//////////////////////////////////////////////////////////////////
void incrementTimeBySecond() {
currentSec ++;
if (currentSec == 60) { // Minutengrenze erreicht?
currentSec = 0; // Ja => Sekundenzeiger auf 0
currentMin++; // und Minuten erhöhen
}
if (currentMin == 60) { // Stundengrenze erreicht?
currentMin = 0; // Ja => Minutenzeiger auf 0
currentHour++; // und Stunden erhöhen
}
if (currentHour == 12) // Nordpol erreicht/12h-Stellung?
currentHour = 0; // Ja => wieder auf 0 zurück
}

//////////////////////////////////////////////////////////////////
//
// Methode: loop()
// Zweck: Uhr implementieren
//
//////////////////////////////////////////////////////////////////
void loop() {
// Uhr anzeigen:
displayClock();
// 1 Sekunde Pause:
delay(1000);
// Neuberechnen der Tageszeit:
incrementTimeBySecond();
}


Saat projesi, ilgili donanım mevcut olduğunda ne kadar az ilginç fikirlerin uygulanabileceğini gösterir.

İlk proje daha çok bir patojen iştahı gibi davrandığından, ilk şakayı bir saniye takip edebiliriz.

bukalemun


Renkler renk veya renk sensörleri yardımıyla ölçülebilir. Prensip olarak, bir kameradaki fotoğraf sensörüne benzer şekilde çalışır. Mekanizma, televizyonlar, bilgisayar veya yazıcı ekranları için kalibrasyon sistemlerinde de kullanılır. Renkleri televizyon görüntüsünden odaya taşıyan Philips Ambighth'i unutmamak için.

Bu baskının ikinci projesinde renk algılama için bir sensör, bir colorimetro adı verilir. Tanınan rengi WS2812B pikselli bir LED şeritte RGB kontrollerine dönüştürüyoruz. Örneğin, adofruit neopiksel ürünleri kullanılarak.

Bu yüzden bir proje hedefi olarak bir bukalemun ile ilgiliyiz.

Bu ikinci sanatsal kurulum için, renk algılama için belirli TCS230 bileşenini kullanıyoruz.




Seatedstudio.com



TCS320 renk sensörü


(Resim: seeedstudio.com)



Dört beyaz sensör LED, ölçüm nesnesini aydınlatmak için kullanılır. Ortada, her biri on altı kırmızı, mavi, yeşil veya beyaz tanıyan 4×16 fotoğraf dijung ile bir IC görebilirsiniz. Bu fotoğraf diyot serileri, S2 ve S3 girişleri yoluyla ayrı ayrı filtrelenir. Diyotların her biri 120 μm x 120 μm'lik bir alana sahiptir. Sadece bir fikre sahip olmak için.

(S2, S3) Filtre

  • (Bas, bas) kırmızı
  • (Düşük, yüksek) mavi
  • (Yüksek, düşük) filtrelenmemiş
  • (Yüksek, yüksek) yeşil
Ölçüm aralığını değiştirmek veya duyarlılığı artırmak için geliştiriciler, frekans aralıklarının modüle edilmesi gereken S0 ve S1 girişleri arasında seçim yapabilir.

(S0, S1) Çıkış Frekansının Bölümü

  • (Bas, bas)
  • (Düşük, yüksek) % 2
  • (Yüksek, düşük) % 20
  • (Uzun, yüksek)% 100
TCS230 renk sensörünün işlevselliğini açıklamak nispeten kolaydır:

  • Işık fotoğraf dijung'a gelir ve orada bir akımı tetikler. Bu zaten Einstein'ın fotoğrafik elektrik efekti üzerindeki çalışması diyor. Dediğim gibi, belirli frekans aralıklarını filtreleyen DiJoices'i kullanıyoruz.
  • Sensörün ayrı bir kısmı, bu akımı, sensörün dışarıdaki çıkışta yaydığı dikdörtgen dürtülerde konuşur. Bu dikdörtgen dürtüler% 50 ve% 50 baskısının% 50'lik bir baskısına sahiptir. Çıkış sinyali, frekansına ilişkin ölçülen ışık sinyali ile orantılıdır.
TCS230, enerjisini giriş v ile elde ederCC ve gnd. Sinyal çıkışı aktif düşük giriş ile etkinleştirilebilir. Bu nedenle, genellikle bu girişi kalıcı olarak GND'ye koyarız.

devre


Sanatsal kurulumumuz için bu devrede, Arduino UNO ve TCS230 arasında aşağıdaki bağlantılarımız var.




TCS230 ile devrenin kızarmış diyagramı



TCS230 ile devrenin kızarmış diyagramı



TC230 Arduino Uno

  • S0 Dijital Çıktı 6
  • S1 Dijital Çıktı 7
  • S2 Dijital Çıktı 4
  • S3 Dijital Çıktı 5
  • Out Dijital Giriş 2 (sinyalleri gözlemlemek için harici kesinti 0)
  • GND GND
  • VCC 5V
  • Oe gnd
LED şeridini WS2812B'ye göre Arduino 13 dijital çıkışına bağlarız.

direksiyon


Programda nispeten basit metro kütüphanesini kullanıyoruz. Normal tekrarlayan éreißen ile başa çıkmak için kullanılır. Dikkat: GitHub kütüphanesinin zip dosyasını indirir indirmez, kütüphaneyi içe aktarmak istiyorsanız Arduino fikrindeki Arduino fikrindeki kütüphaneyi seçmeyin. Aksi takdirde bir hata mesajı alırsınız. Bunun yerine, kütüphaneyi içe aktarmak için alt dizin metrosuna göz atarlar.


Metro kütüphanesi


Değişken, bu örnek programda metro kitaplığından mevcuttur ledMetro.

Bu 250 milisaniye için önceden ayarlanmıştır. Sonsuz döngüde, kullanarak kontrollü eskiz kullanılarak

if (ledMetro.check() == 1) { ... }

Eğer bu sefer zaten ulaşıldı. Bu durumda, LED'in yanıp sönmesine izin verin.

#include <Metro.h> //Include Metro library
#define LED 13 // Define the led's pin
//Create a variable to hold theled's current state
int state = HIGH;

// Instanciate a metro object and set the interval to 250 milliseconds (0.25 seconds).
Metro ledMetro = Metro(250);

void setup()
{
pinMode(LED,OUTPUT);
digitalWrite(LED,state);
}

void loop()
{
if (ledMetro.check() == 1) { // check if the metro has passed its interval .
if (state==HIGH) state=LOW;
else state=HIGH;
digitalWrite(LED,state);
}
}







Bunun yerine, bölümün bilgisini zamanlayıcılardaki her zaman kullanabilirsiniz, bu da çok güzel bir görevdir.

Bu bölümün ikinci programına nüfuz etmek nispeten kolaydır, bu yüzden bu noktada gereksiz tekrarlar hariç.

Yorumları kod aracılığıyla iyi yönlendirmelisiniz.

///////////////////////////////////////////////////////
//
// Ansteuerung des Farberkennungssensors TCS230
//
///////////////////////////////////////////////////////
// Import der Neopixel Bibliothek:
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif

// Import der Metro-Bibliothek:
#include <Metro.h> // library
#include <math.h>

const int S0 = 6; // S2 und S3 definieren die Modulation
const int S1 = 7; // der Ausgabefrequenz
const int S2 = 4; // S0 und S1 selektieren die Photodioden
const int S3 = 5; // bzw. Filter
const int RGB = 13; // Anschluss der RGB LEDs
const int OUT = 2; // Hier liegt das Ausgabesignal des Sensors an

// Zähler vereinbaren:
unsigned int cntr = 0; // globaler Zähler
unsigned int cntrR = 0; // roter Zähler
unsigned int cntrG = 0; // grüner Zähler
unsigned int cntrB = 0; // blauer Zähler
unsigned int cntrRavg = 0; // durchschnittlicher Rotwert
unsigned int cntrGavg = 0; // durchschnittlicher Grünwert
unsigned int cntrBavg = 0; // durchschnittlicher Blauwert

// Metroobjekte für Zeitmanagement:
Metro illuminate = Metro(60); // leuchten
Metro getSensorData = Metro(50); // verarbeiten
Metro triggerSensor = Metro(10); // messen

// Initialisieren eines Neopixel-Zugriffsobjekts mit 64 LEDs:



Adafruit_NeoPixel strip = Adafruit_NeoPixel(64, RGB, NEO_GRB + NEO_KHZ800);
// Diverse Farbfilter des TCS230:
enum {
NoFilter = 0,
RedFilter = 1,
GreenFilter = 2,
BlueFilter = 3
};

uint8_t sensorFlag = NoFilter; // initial kein Filter

///////////////////////////////////////////////////////
// Methode zum Durchlaufen der Farbfilter-Codes:
///////////////////////////////////////////////////////
void nextSensorFlag () {
sensorFlag = (sensorFlag + 1) % 4;
}

///////////////////////////////////////////////////////
//
// Methode: display
// Parameter: color = Farbe
// Zweck: lässt alle Pixel in color erstrahlen
//
///////////////////////////////////////////////////////
void display(uint8_t red, uint8_t green, uint8_t blue) {
uint32_t color; // Komponierter RGB Farbwert
uint8_t * rgb = (uint8_t *)&color;
rgb[3] = 0; // Weißanteil
rgb[2] = red; // rote Komponente
rgb[1] = green; // grüne Komponente
rgb[0] = blue; // blaue Komponente

// Gewünschte Farbe am LED-Streifen darstellen:
for(uint16_t pixno=0; pixno<strip.numPixels(); pixno++) {
strip.setPixelColor(pixno, color);
strip.show();
}
}

///////////////////////////////////////////////////////
// Bei jedem Interrupt an Eingang 2 => Aufruf ISR
///////////////////////////////////////////////////////
void ISR_Counter() {
cntr++;
}

///////////////////////////////////////////////////////
//
// Methode: setup
// Zweck: Initialisierung
//
///////////////////////////////////////////////////////
void setup()
{
// Ausgabe am seriellen Monitor einschalten:
Serial.begin(9600);

pinMode(S0, OUTPUT); // S0, S1, S2, S3 sind Eingänge des Sensors
pinMode(S1, OUTPUT); // S0 und S1 definieren Ausgabefrequenz
pinMode(S2, OUTPUT); // S2 und S3 definieren Farbfilterauswahl
pinMode(S3, OUTPUT);
pinMode(OUT, INPUT); // OUT ist ein Ausgang des Sensors
pinMode(RGB,OUTPUT); // LED-Streifen oder -Matrix

// Leuchtstreifen initialisieren und alle LEDs anfangs ausschalten:
strip.begin();
strip.show();
}

////////////////////////////////////////////////////////////////////
//
// Methode: loop()
//
// Zweck:
// Wir selektieren schrittweise die Photodioden für Rot, Grün, Blau,
// messen die entsprechenden Anteile im Frequenzband,
// und geben das Ergebnis aus
//
////////////////////////////////////////////////////////////////////

void loop()
{
// Ausgabefrequenz auf 100% einstellen:
digitalWrite(S0,HIGH);
digitalWrite(S1,HIGH);

// Wir melden eine Interruptroutine für Pin 2 (= Interrupt 0) an.
// Auslösung erfolgt bei Signalwechsel am externen Pin 2:
attachInterrupt(0, ISR_Counter, CHANGE);

// zunächst Messung auslösen:
if (triggerSensor.check()) {
nextSensorFlag();
switch(sensorFlag) {
case RedFilter:
// Rotfilter einschalten:
digitalWrite(S2,LOW);
digitalWrite(S3,LOW);
cntrR=cntr;
// Grünfilter einschalten:
digitalWrite(S2,HIGH);
digitalWrite(S3,HIGH);
break;
case GreenFilter:
cntrG=cntr;
// Blaufilter einschalten:
digitalWrite(S2,LOW);
digitalWrite(S3,HIGH);
break;
case BlueFilter:
cntrB=cntr;
// Rotfilter einschalten:
digitalWrite(S2,LOW);
digitalWrite(S3,LOW);
nextSensorFlag();
break;
}
cntr = 0; // Zähler auf 0 zurücksetzen
}

// danach Durchschnitte berechnen, um Fehler zu kompensieren:
if (getSensorData.check()) {
const int PROBES = 8; // Zahl der Messungen
static int reds [PROBES] = { 0 }; // Alles mit 0 vorbelegen
static int blues [PROBES] = { 0 };
static int greens[PROBES] = { 0 };

// alle Messungen durchlaufen:
for(int measurement = PROBES-1; measurement > 0; measurement--) {
reds [measurement] = reds [measurement-1];
blues [measurement] = blues [measurement-1];
greens[measurement] = greens[measurement-1];
}

if(cntrR < 2500) // realistischer Wert?
reds [0] = cntrR;
else // kompensieren
reds [0] = reds [1];

if(cntrB < 2500) // realistischer Wert?
blues [0] = cntrB;
else // kompensieren
blues [0] = blues [1];

if(cntrG < 2500) // realistischer Wert?
greens[0] = cntrG;
else // kompensieren
greens[0] = greens[1];

cntrRavg = 0; // Durchschnitte mit 0 initialisieren


cntrGavg = 0;
cntrBavg = 0;
// alle Ergebnisse der Messungen aufaddieren:
for(int probe = 0; probe <= PROBES - 1; probe++){
cntrRavg += reds [probe];
cntrGavg += greens[probe];
cntrBavg += blues [probe];
}

// Durchschnitt der Messungen berechnen:
cntrRavg /= PROBES;
cntrGavg /= PROBES;
cntrBavg /= PROBES;
}

// Ergebnisse in RGB-Werte transformieren und erkannte Farbe
// ausgeben:
if (illuminate.check()) {
uint8_t red = map(constrain(cntrRavg, 350,1700), 350, 1700, 0, 255);
uint8_t green = map(constrain(cntrGavg, 350,1650), 350, 1650, 0, 255);
uint8_t blue = map(constrain(cntrBavg, 350,1500), 350, 1500, 0, 255);

// Gemessene Farbe am Neopixel ausgeben:
display(red, green, blue);
}
}


Renk sensörü renkli bir nesnenin yanına getirildiğinde, karşılık gelen bir piksel renk değişikliğini gözlemlemek gerekir. Renk algılamasının doğruluğu, sensör ve hedef nesne arasındaki mesafeye de bağlıdır. Yoğun bir deneyle, diğer bağlantıları tanıyabilirsiniz. Ayrıca araba çözümünün güçlü ve zayıf yönlerini de bileceksiniz.

Özet


Bu çok ayrıntılı bölümde iki sanatsal projeyle tanıştınız. Bununla birlikte, renk oyununun konusu yaratıcı fikirler için çok minnettardır. Belki bir veya diğer güzel fikri uygulayabilir ve başkalarının katılmasını sağlayabilirsiniz.

Ancak, ışık konusunu hiç tamamlamadık. Ancak bir sonraki bölümde, arzu konusu Lazer ile projelerde değişir.




()
 
Cevap yazmak için giriş yap yada kayıt ol.
Üst