Kapazitive Touch-Stimmung/Ambilight - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:23

Dieses instructable ist eine schnelle Beschreibung meiner Erfahrung, die ein multifunktionales Stimmungslicht erstellt. Grundkenntnisse in elektronischen Schaltungen werden erwartet. Das Projekt ist noch nicht abgeschlossen, es müssen noch einige Funktionen hinzugefügt und optimiert werden, aber es ist bereits funktionsfähig. Wenn Sie von diesem instructable begeistert sind, werde ich es aktualisieren. Das Herzstück des Systems ist ein Arduino. Es verarbeitet die Eingabe von USB oder jedem der kapazitiven Touch-Eingänge und steuert das RGB-Licht. Dieses anweisbare ist in drei Abschnitte unterteilt: - Der kapazitive Berührungsabschnitt deckt die unsichtbaren Eingabetasten ab - Der Stimmungslichtabschnitt deckt die Steuerung des Stimmungslichts ab. Haftungsausschluss: Elektronik kann gefährlich sein, für eventuelle Schäden sind Sie selbst verantwortlich. Ein Teil des Codes wird aus Foren gesammelt und enthält möglicherweise nicht den Namen seines Besitzers. Bitte lassen Sie es mich wissen und ich füge Ihren Namen hinzu.

Schritt 1: Artikelliste

Die folgenden Komponenten werden für dieses anweisbare benötigt: - Arduino + USB-Kabel - Breadboard - Computer-Netzteil - 3x RGB-Streifen, check out dealextreme.com. - 3x TIP120 FETs, wie https://uk.farnell.com/stmicroelectronics/tip120 /darlington-transistor-to-220/dp/9804005- Eine Reihe von Widerständen (6 * 10 KiloOhm, 3 * 2 MegaOhm) - Viel Draht. - Werkzeuge Kapazitiver Touch - Metallringe für Grundplatten - Kupferdraht oder -platte - Etwas zum Einbauen (wie ein Bücherregal:)

Schritt 2: Kapazitiver Touch - Grundlagen & Schaltung

Da ich meine Bücherregale bemalte, hatte ich die Möglichkeit, sie auch zu 'aufwerten'. Ich wollte das Stimmungslicht durch unsichtbare Berührung steuern. Mein Plan war zunächst, dafür einen dedizierten IC (wie den Atmel QT240) zu verwenden. Aber dann stolperte ich über eine Seite, auf der erklärt wurde, dass der Arduino per Software einen kapazitiven Sensor emulieren kann. Die elektronische Schaltung ist im Bild zu finden, der Sensor ist ein spiralförmiger Kupferdraht (der Einfachheit halber ist nur einer gezeigt). Die Empfindlichkeit wird durch die Widerstände vor jedem Pin gesteuert. Sie können von 1 MegaOhm (absolute Berührung) bis 40 MegaOhm (12-24 Zoll entfernt) reichen, je nachdem, ob eine absolute oder nahe Berührung erforderlich ist (ich habe am Ende 2M Ohm-Widerstände verwendet). Experimentieren Sie mit den Werten, bis sich der Sensor wie gewünscht verhält. Es ist eine gute Idee, eine leitende Oberfläche (durch ein dünnes nichtleitendes Stück getrennt) zu installieren, die mit der Masse der Schaltkreise auf der Rückseite jeder Spirale verbunden ist. Auf diese Weise werden die Sensoren stabiler und weniger durch Rauschen beeinflusst. Einige weitere Bilder zum Einbau der Sensoren in ein Bücherregal. Ein Stecker ist ebenfalls installiert, um später eine einfache Verbindung mit der Schaltung zu ermöglichen. Füller wird verwendet, um alles zu kaschieren, und danach sind sie fertig zum Bemalen.

Schritt 3: Kapazitiver Touch - Code & Testen

Der folgende Quellcode kann auf dem Arduino zum Debuggen verwendet werden, überprüfen Sie die Werte mit dem seriellen Arduino-Monitor. Es werden sechs Werte generiert. Die erste ist ein Maß für die Leistung des Systems. Der zweite bis sechste sind die erfassten Werte an jedem Pin. Die Werte sollten steigen, wenn Sie sich Ihrem Finger nähern. Wenn nicht, überprüfen Sie auf schlechte Verbindungen und Interferenzen. Die Widerstandswerte können geändert werden, um die Empfindlichkeit zu bestimmen. Durch Implementieren einer Wenn-Dann-Struktur, die bei einer bestimmten logischen Schwelle aktiviert wird, kann eine Umschaltung vorgenommen werden. Dies wird im endgültigen Arduino-Code verwendet cs_2_3 = CapSense(2, 4); // 10M Widerstand zwischen Pins 2 & 4, Pin 4 ist Sensorpin, Draht hinzufügen, FolieCapSense cs_2_4 = CapSense (2, 7); // 10M Widerstand zwischen Pins 2 & 7, Pin 7 ist Sensorpin, Draht hinzufügen, FolieCapSense cs_2_5 = CapSense (2, 8); // 10M Widerstand zwischen Pins 2 & 8, Pin 8 ist Sensorpin, fügen Sie Draht hinzu, FolieCapSense cs_2_6 = CapSense (2, 12); // 10M Widerstand zwischen Pins 2 & 12, Pin 12 ist Sensorpin, Draht hinzufügen, FolieCapSense cs_2_7 = CapSense (2, 13); // 10M Widerstand zwischen Pins 2 & 13, Pin 13 ist Sensorpin, Draht hinzufügen, Foilvoid setup () { Serial.begin (9600);} void loop () { long start = millis (); long total1 = cs_2_3.capSense(30); long total2 = cs_2_4.capSense(30); long total3 = cs_2_5.capSense(30); long total4 = cs_2_6.capSense(30); long total5 = cs_2_7.capSense(30); Serial.print (millis () - starten); // Leistung in Millisekunden überprüfen Serial.print ("\t"); // Tabulatorzeichen für Debug-Fensterabstand Serial.print (total1); // Drucksensorausgang 1 Serial.print ("\t"); Serial.print (total2); // Drucksensorausgang 2 Serial.print ("\t"); Serial.print (total3); // Drucksensorausgang 3 Serial.print ("\t"); Serial.print (total4); // Drucksensorausgang 4 Serial.print ("\t"); Serial.println (total5); // Drucksensorausgang 5 Verzögerung (10); // willkürliche Verzögerung, um die Daten auf den seriellen Port zu begrenzen}--- END ---

Schritt 4: Stimmungslicht - Grundlagen & Schaltung

Jetzt ist es an der Zeit, den Ausgabeteil des Systems zu erstellen. Die PWM-Pins des Arduino werden verwendet, um jede Farbe zu steuern. PWM bedeutet Pulsweitenmodulation, durch sehr schnelles Ein- und Ausschalten eines Pins werden die LEDs von 0 bis 255 gedimmt. Jeder Pin wird von einem FET verstärkt. Derzeit hat das System nur einen Kanal pro Farbe, was bedeutet, dass alle RGB-Streifen auf einmal angesteuert werden und 3 PWM-Pins benötigt werden (einer für jede Farbe). In Zukunft möchte ich jeden meiner vier RGB-Streifen ansteuern können. Das bedeutet 4 * 3 = 12 PWM-Pins (und wahrscheinlich ein Arduino Mega). Ok, Zeit für ein paar Schaltpläne! Dies (siehe Bild) ist eine grundlegende Darstellung der Schaltung (wird bald eine schönere machen). Die kapazitiven Sensoren sind ebenfalls enthalten (grüner Teil). Grundsätzlich gibt es drei Komponenten, die erklärt werden müssen:- FETDies ist der Verstärker, von dem ich gesprochen habe. Es hat ein Tor, eine Quelle und einen Abfluss. Es verstärkt die Sinne einen kleinen Strom am Gate (verbunden mit dem Arduino) und öffnet den Weg für den RGB-Streifen, der mit 12 Volt betrieben wird. Source sollte auf +12V liegen, Drain auf GND (Masse). Überprüfen Sie das Datenblatt Ihres FET für die genaue Pinbelegung. Jeder RGB-Kanal sollte vor seinem eigenen FET positioniert werden. In diesem Sinne verhält es sich wie ein Arduino-gesteuerter Schalter.- RGB-Streifen Dieser 12-Volt-RGB-Streifen ist vom gemeinsamen Anodentyp (+). Das bedeutet, dass der gemeinsame Draht an +12V angeschlossen werden sollte und der Strom durch jeden der separaten Farbkanäle fließt. Der Streifen hat Widerstände eingebaut, also keine Sorge! - WiderständeDrei 10k-Widerstände stellen sicher, dass der FET nicht einschaltet, wenn er nicht eingeschaltet werden soll. Drei andere begrenzen den maximalen Strom, den der FET ableiten wird. Die oberen drei Widerstände sind bereits im RGB-Streifen. An die RGB-Streifen habe ich USB-Kabel angelötet, damit ich sie einfach modular anschließen kann. Stecker von einem alten Hub werden auf mein Steckbrett gelegt. Verwenden Sie ein altes Computernetzteil für Saft, 12 V für die Stromversorgung des RGB-Streifens und schließlich 5 V für den Stromkreis, wenn Sie möchten, dass er ohne USB-Kabel läuft.

Schritt 5: Stimmungslicht - Code & Steuerung

Das Stimmungslicht wird durch die kapazitiven Sensoren gesteuert. Vorerst habe ich nur die Sensoren 2 & 3 für den Farbwechsel programmiert. Die anderen Sensoren haben noch keine Funktion. Hier ist der Code: --- Arduino Mood Control Code --- #include const boolean invert = true; const long timeout = 10000; // Kapazitive SensordeklarationCapSense In1 = CapSense (2, 4); // 2M Widerstand zwischen Pins 4 & 2, Pin 2 ist Sensorpin, Draht hinzufügen, FolieCapSense In2 = CapSense (2, 7); // 2M Widerstand zwischen Pins 4 & 6, Pin 6 ist Sensorpin, Draht hinzufügen, FolieCapSense In3 = CapSense (2, 8); // 2M Widerstand zwischen Pins 4 & 8, Pin 8 ist Sensorpin, Draht hinzufügen, FolieCapSense In4 = CapSense (2, 12); // 2M Widerstand zwischen Pins 4 & 8, Pin 8 ist Sensorpin, Draht hinzufügen, FolieCapSense In5 = CapSense (2, 13); // 2M Widerstand zwischen Pins 4 & 8, Pin 8 ist Sensorpin, Draht hinzufügen, Folie // PWM Pin-Deklarationenint PinR1 = 3;int PinG1 = 5;int PinB1 = 6; // Andere Variablenint Color1 = 128; // Beginnen Sie mit einem Rot wie colorint Brightness1 = 255; // Start bei voller Helligkeitint RedValue1, GreenValue1, BlueValue1; // Die RGB-Komponentenvoid setup () { // Sensor-Timeout-Werte setzen In1.set_CS_AutocaL_Millis (timeout); In2.set_CS_AutocaL_Millis(Zeitüberschreitung); In3.set_CS_AutocaL_Millis(Zeitüberschreitung); In4.set_CS_AutocaL_Millis(Zeitüberschreitung); In5.set_CS_AutocaL_Millis(timeout);}void loop() { long start = millis(); long total1 = In1.capSense(30); long total2 = In2.capSense(30); long total3 = In3.capSense(30); long total4 = In4.capSense(30); long total5 = In5.capSense(30); if (total2 > 150) { Color1++; // Inkrementiere die Farbe if (Color1 > 255) {// Color1 = 0; }} else if (total3 > 200) { Color1--; // dekrementiere die Farbe if (Color1 < 0) { // Color1 = 255; } // Farbton in RGB umwandeln hueToRGB(Color1, Brightness1); // Farben auf PWM-Pins schreiben analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // Funktion zum Konvertieren einer Farbe in ihre Rot-, Grün- und Blaukomponenten.void hueToRGB (int hue, int bright) { unsigned int scaledHue = (hue * 6); unsigned int segment = scaledHue / 256; // Segment 0 bis 5 um das Farbrad unsigned int segmentOffset = scaledHue - (Segment * 256); // Position innerhalb des Segments unsigned int Kompliment = 0; unsigned int prev = (Helligkeit * (255 - segmentOffset)) / 256; unsigned int next = (Helligkeit * segmentOffset) / 256; if(invert) {Helligkeit = 255-Helligkeit; Kompliment = 255; Vorher = 255-Vorher; nächste = 255-nächste; aufrechtzuerhalten. Schalter (Segment) { Fall 0: // Rot RedValue1 = Helligkeit; GreenValue1 = weiter; BlueValue1 = Kompliment; brechen; Fall 1: // gelb RedValue1 = prev; GreenValue1 = Helligkeit; BlueValue1 = Kompliment; brechen; Fall 2: // grün RedValue1 = Kompliment; GreenValue1 = Helligkeit; BlueValue1 = weiter; brechen; Fall 3: // Cyan RedValue1 = Kompliment; GreenValue1 = zurück; BlueValue1 = Helligkeit; brechen; Fall 4: // blau RedValue1 = next; GreenValue1 = Kompliment; BlueValue1 = Helligkeit; brechen; Fall 5: // Magenta Standard: RedValue1 = Helligkeit; GreenValue1 = Kompliment; BlueValue1 = zurück; brechen; }}--- ENDE ---

Schritt 6: Ambi Light - Arduino-Seite

Natürlich wäre es total cool, das Stimmungslicht von Ihrem Computer aus steuern zu können. Zum Beispiel um ein Ambilight oder eine musikgesteuerte Disco zu erstellen. Dieser Abschnitt konzentriert sich auf den Ambilight-Teil, in Zukunft werde ich mehr Funktionalität hinzufügen. Nun, es gibt keine zusätzliche Schaltung, da alles im Arduino verfügbar ist. Was wir verwenden werden, sind die seriellen Kommunikationsfähigkeiten und etwas 'Processing 1.0'-Software. Schließen Sie Ihr Arduino über ein USB-Kabel an Ihren Computer an (wenn Sie Skizzen darauf hochladen, ist dies bereits der Fall). Für das Arduino müssen Sie einen zusätzlichen Code für die serielle Kommunikation hinzufügen. Der Code wechselt in den Hörmodus und schaltet die kapazitiven Sensoren aus, solange er RGB-Werte vom Computer empfängt. Es setzt dann die RGB-Werte auf die PWM-Pins. Dies ist mein letzter Code für den Moment, überprüfen Sie die Änderungen selbst: --- Arduino Ambilight Code ---#include const boolean invert = true;const long timeout = 10000;long commStart = 0;char val; // Kapazitive SensordeklarationCapSense In1 = CapSense(2, 4); // 2M Widerstand zwischen Pins 4 & 2, Pin 2 ist Sensorpin, Draht hinzufügen, FolieCapSense In2 = CapSense (2, 7); // 2M Widerstand zwischen Pins 4 & 6, Pin 6 ist Sensorpin, Draht hinzufügen, FolieCapSense In3 = CapSense (2, 8); // 2M Widerstand zwischen Pins 4 & 8, Pin 8 ist Sensorpin, Draht hinzufügen, FolieCapSense In4 = CapSense (2, 12); // 2M Widerstand zwischen Pins 4 & 8, Pin 8 ist Sensorpin, Draht hinzufügen, FolieCapSense In5 = CapSense (2, 13); // 2M Widerstand zwischen Pins 4 & 8, Pin 8 ist Sensorpin, Draht hinzufügen, Folie // PWM Pin-Deklarationenint PinR1 = 3;int PinG1 = 5;int PinB1 = 6; // Andere Variablenint Color1 = 128; // Beginnen Sie mit einem Rot wie colorint Brightness1 = 255; // Start bei voller Helligkeitint RedValue1, GreenValue1, BlueValue1; // Die RGB-Komponentenvoid setup () { Serial.begin (9600); // serielle Kommunikation starten // Sensor-Timeout-Werte einstellen In1.set_CS_AutocaL_Millis (timeout); In2.set_CS_AutocaL_Millis(Zeitüberschreitung); In3.set_CS_AutocaL_Millis(Zeitüberschreitung); In4.set_CS_AutocaL_Millis(Zeitüberschreitung); In5.set_CS_AutocaL_Millis(timeout);}void loop() { long start = millis(); long total1 = In1.capSense(30); long total2 = In2.capSense(30); long total3 = In3.capSense(30); long total4 = In4.capSense(30); long total5 = In5.capSense(30); if (Serial.available ()) {// Wenn Daten zum Lesen verfügbar sind, val = Serial.read (); // Lesen Sie es und speichern Sie es in val commStart = millis (); if (val == 'S') { //Wenn Startzeichen empfangen wird, while (!Serial.available()) {} //Warten bis zum nächsten Wert. RedValue1 = Serial.read(); //Sobald verfügbar, zuweisen. while (!Serial.available()) {} //Wie oben. GreenValue1 = Serial.read(); while (!Serial.available()) {} BlueValue1 = Serial.read(); } Serial.print (RedValue1); Serial.print (GreenValue1); Serial.println (BlueValue1); aufrechtzuerhalten. Sonst if ((millis() - commStart) > 1000) { if (total2 > 150) { Color1++; // Inkrementiere die Farbe if (Color1 > 255) {// Color1 = 0; }} else if (total3 > 200) { Color1--; // dekrementiere die Farbe if (Color1 < 0) { // Color1 = 255; } } hueToRGB(Farbe1, Helligkeit1); } analogWrite (PinR1, RedValue1); analogWrite (PinG1, GreenValue1); analogWrite (PinB1, BlueValue1);} // Funktion zum Konvertieren einer Farbe in ihre Rot-, Grün- und Blaukomponenten.void hueToRGB (int hue, int bright) { unsigned int scaledHue = (hue * 6); unsigned int segment = scaledHue / 256; // Segment 0 bis 5 um das Farbrad unsigned int segmentOffset = scaledHue - (Segment * 256); // Position innerhalb des Segments unsigned int Kompliment = 0; unsigned int prev = (Helligkeit * (255 - segmentOffset)) / 256; unsigned int next = (Helligkeit * segmentOffset) / 256; if(invert) {Helligkeit = 255-Helligkeit; Kompliment = 255; Vorher = 255-Vorher; nächste = 255-nächste; aufrechtzuerhalten. Schalter (Segment) { Fall 0: // Rot RedValue1 = Helligkeit; GreenValue1 = weiter; BlueValue1 = Kompliment; brechen; Fall 1: // gelb RedValue1 = prev; GreenValue1 = Helligkeit; BlueValue1 = Kompliment; brechen; Fall 2: // grün RedValue1 = Kompliment; GreenValue1 = Helligkeit; BlueValue1 = weiter; brechen; Fall 3: // Cyan RedValue1 = Kompliment; GreenValue1 = zurück; BlueValue1 = Helligkeit; brechen; Fall 4: // blau RedValue1 = next; GreenValue1 = Kompliment; BlueValue1 = Helligkeit; brechen; Fall 5: // Magenta Standard: RedValue1 = Helligkeit; GreenValue1 = Kompliment; BlueValue1 = zurück; brechen; }}--- ENDE ---

Schritt 7: Ambi Light - Computerseite

Auf der Seite des Computers wird eine Processing 1.0-Skizze ausgeführt, siehe Processing.org. Dieses kleine (etwas unordentliche) Programm berechnet zu jedem Zeitpunkt die durchschnittliche Bildschirmfarbe und sendet diese an die serielle Schnittstelle. Es ist noch sehr einfach und könnte einige Optimierungen gebrauchen, aber es funktioniert sehr gut! Ich werde es in Zukunft für mehrere separate RGB-Streifen und Bildschirmabschnitte aktualisieren. Das können Sie auch selbst machen, die Sprache ist recht einfach. Hier ist der Code: --- Processing 1.0 Code ---import processing.serial.*;import java.awt. AWTException;import java.awt. Robot;import java.awt. Rectangle;import java.awt.image. BufferedImage;PImage screenShot;Serial myPort;static public void main(String args) { PApplet.main(new String { "--present", "shooter" });}void setup() { size(100, 100); // Größe (screen.width, screen.height); // Eine Liste der seriellen Ports für Debugging-Zwecke ausgeben: println(Serial.list()); // Ich weiß, dass der erste Port in der seriellen Liste auf meinem Mac // immer mein FTDI-Adapter ist, also öffne ich Serial.list()[0]. // Auf Windows-Rechnern öffnet dies im Allgemeinen COM1. // Öffnen Sie den Port, den Sie verwenden. String portName = Serial.list()[0]; myPort = new Serial (this, portName, 9600);}void draw () {//image (screenShot, 0, 0, width, height); screenShot = getScreen(); Farbe kleur = Farbe (0, 0, 0); kleur = Farbe (Screenshot); //myPort.write(int(red(kleur))+', '+int(green(kleur))+', '+int(blue(kleur))+13); //myPort.write (int (rot (kleur))); //meinPort.write(', '); //myPort.write (int (grün (kleur))); //meinPort.write(', '); //myPort.write (int (blau (kleur))); //meinPort.write (13); füllen (kleur); rect(30, 20, 55, 55);}Farbfarbe (PImage img) { int cols = (img.width); int rows = (img.height); int dimension = (img.width*img.height); intr = 0; intg = 0; intb = 0; img.loadPixels(); // Ga elke pixel langs (dimension)for (int i = 0; i < (dimension/2); i++) { r = r + ((img.pixels >> 16) & 0xFF); g = g + ((img.pixels >> 8) & 0xFF); b = b + (img.pixels & 0xFF);}int mean_r = r/(Dimension/2);int mean_g = g/(Dimension/2);int mean_b = b/(Dimension/2);Farbe mean_clr = color(mean_r, mean_g, mean_b); myPort.write('S'); meinPort.write(mean_r); meinPort.write(mean_g); myPort.write(mean_b);return (mean_clr);}PImage getScreen() { GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice gs = ge.getScreenDevices(); DisplayMode-Modus = gs[0].getDisplayMode(); Rechteckgrenzen = new Rectangle(0, 0, mode.getWidth(), mode.getHeight()); BufferedImage desktop = new BufferedImage(mode.getWidth(), mode.getHeight(), BufferedImage. TYPE_INT_RGB); try { desktop = new Robot(gs[0]).createScreenCapture(bounds); } catch(AWTException e) { System.err.println("Bildschirmaufnahme fehlgeschlagen."); } return (new PImage(desktop));}--- END ---

Schritt 8: Ergebnis

Und das ist das Ergebnis, es ist tatsächlich an der Unterseite meines Bettes. Ich muss das Tuch noch ersetzen, es wird das Licht mehr streuen. Mehr Bilder dazu bald. Ich hoffe, Sie mögen dieses instructable und ich hoffe auch, dass es eine Basis für Ihre eigene Kreativität ist. Aus Zeitgründen habe ich es sehr schnell geschrieben. Sie benötigen möglicherweise einige grundlegende Arduino- / Elektronikkenntnisse, um es zu verstehen, aber ich plane, es in Zukunft zu aktualisieren, wenn es gut angenommen wird.