Capacitieve Touch Mood/Ambilight - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:20

Dit instructable is een snelle beschrijving van mijn ervaring met het maken van een multifunctionele moodlight. Enige basiskennis van elektronische schakelingen wordt verwacht. Het project is nog niet klaar, er moeten nog wat functionaliteiten en aanpassingen worden gedaan, maar het is al functioneel. Als jullie enthousiast zijn over deze instructable, zal ik deze updaten. Het hart van het systeem is een Arduino. Het zal de invoer van USB of elk van de capacitieve aanraakinvoer verwerken en het RGB-licht regelen. Deze instructable is opgesplitst in drie secties: - Het capacitieve aanraakgedeelte omvat de onzichtbare invoerknoppen - Het sfeerlichtgedeelte behandelt de besturing van het sfeerlicht - Het ambilight-gedeelte behandelt invoer via de seriële poort en verwerkt RGB-waarden gegenereerd door een computerprogramma om de lichten te bedienen. Disclaimer: Elektronica kan gevaarlijk zijn, u bent zelf verantwoordelijk voor eventuele schade. Sommige code wordt verzameld van forums en bevat mogelijk niet de naam van de eigenaar. Laat het me weten en ik zal je naam toevoegen.

Stap 1: Itemlijst

De volgende componenten zijn nodig voor deze instructable:- Arduino + USB-kabel- Breadboard- Computervoeding- 3x RGB-strips, kijk op dealextreme.com.- 3x TIP120 FET's, zoals https://uk.farnell.com/stmicroelectronics/tip120 /darlington-transistor-to-220/dp/980405- Een heleboel weerstanden (6* 10 kiloOhm, 3 * 2 megaOhm)- Veel draad. - Gereedschap Capacitieve aanraking - Metalen ringen voor grondplaten- Koperdraad of plaat- Iets om het in te bouwen (zoals een boekenplank:)

Stap 2: Capacitieve Touch - Basis & Circuit

Omdat ik mijn boekenplanken aan het schilderen was, had ik de mogelijkheid om ze ook te 'upgraden'. Ik wilde de sfeerverlichting aansturen door middel van onzichtbare aanraking. In eerste instantie was mijn plan om hiervoor een speciale IC te gebruiken (zoals de Atmel QT240). Maar toen stuitte ik op een pagina waarin werd uitgelegd dat de Arduino een capacitieve sensor kan emuleren door middel van software. Het elektronische circuit is te vinden in de afbeelding, de sensor is een spiraalvormige koperdraad (slechts één wordt getoond voor de eenvoud). De gevoeligheid wordt geregeld door de weerstanden die voor elke pin worden gevonden. Ze kunnen variëren van 1 MegaOhm (absolute aanraking) tot 40 MegaOhm (12-24 inch afstand), afhankelijk van of absolute of bijna-aanraking nodig is (ik heb uiteindelijk 2M Ohm-weerstanden gebruikt). Experimenteer met de waarden totdat de sensor zich naar wens gedraagt. Het is een goed idee om een geleidend oppervlak te installeren (gescheiden door een dun niet-geleidend stuk) dat is aangesloten op de aarde van de circuits aan de achterkant van elke spiraal. Op deze manier zullen de sensoren stabieler zijn en minder beïnvloed door ruis. Nog enkele foto's over het installeren van de sensoren in een boekenplank. Er is ook een stekker geïnstalleerd om later gemakkelijk met het circuit te kunnen worden verbonden. Filler wordt gebruikt om alles te verbergen en daarna zijn ze klaar om te worden geverfd.

Stap 3: Capacitieve aanraking - coderen en testen

De volgende broncode kan op de Arduino worden gebruikt voor debuggen, controleer de waarden met de arduino seriële monitor. Er worden zes waarden gegenereerd. De eerste is een maatstaf voor de prestaties van het systeem. De tweede tot en met de zesde zijn de waargenomen waarden op elke pin. De waarden zouden moeten stijgen wanneer u uw vinger nadert. Als dit niet het geval is, controleer dan op slechte verbindingen en interferentie. De weerstandswaarden kunnen worden gewijzigd om de gevoeligheid te bepalen. Door een als-dan-structuur te implementeren die bij een bepaalde logische drempel wordt geactiveerd, kan worden omgeschakeld. Dit zal worden gebruikt in de uiteindelijke Arduino-code. Meer informatie, voorgesteld om te lezen: https://www.arduino.cc/playground/Main/CapSense--- Arduino CapTouch Debugging Code ---#include void setup() {CapSense cs_2_3 = CapSense(2, 4); // 10M weerstand tussen pinnen 2 en 4, pin 4 is sensorpin, draad toevoegen, foilCapSense cs_2_4 = CapSense (2, 7); // 10M weerstand tussen pinnen 2 en 7, pin 7 is sensorpin, draad toevoegen, foilCapSense cs_2_5 = CapSense (2, 8); // 10M weerstand tussen pinnen 2 en 8, pin 8 is sensorpin, draad toevoegen, foilCapSense cs_2_6 = CapSense (2, 12); // 10M weerstand tussen pinnen 2 en 12, pin 12 is sensorpin, draad toevoegen, foilCapSense cs_2_7 = CapSense (2, 13); // 10M weerstand tussen pinnen 2 en 13, pin 13 is sensorpin, draad toevoegen, foilvoid setup() {Serial.begin(9600);}void loop() {long start = millis(); lang totaal1 = cs_2_3.capSense (30); lang totaal2 = cs_2_4.capSense (30); lang totaal3 = cs_2_5.capSense (30); lang totaal4 = cs_2_6.capSense (30); lang totaal5 = cs_2_7.capSense (30); Serial.print(millis() - start); // controleer de prestaties in milliseconden Serial.print ("\t"); // tabteken voor debug windown spacing Serial.print (totaal1); // print sensor output 1 Serial.print ("\t"); Serial.print(totaal2); // print sensor output 2 Serial.print("\t"); Seriële.afdruk (totaal3); // print sensor output 3 Serial.print("\t"); Serial.print(totaal4); // print sensor output 4 Serial.print("\t"); Serieel.println(totaal5); // printsensor uitgang 5 vertraging (10); // willekeurige vertraging om gegevens te beperken tot seriële poort}--- END ---

Stap 4: Mood Light - Basis & Circuit

Nu is het tijd om het uitvoergedeelte van het systeem te bouwen. De PWM-pinnen van de Arduino worden gebruikt om elke kleur te besturen. PWM staat voor Pulse Width Modulation, door zeer snel een pin aan en uit te zetten worden de leds gedimd van 0 naar 255. Elke pin wordt versterkt door een FET. Voorlopig heeft het systeem slechts één kanaal per kleur, wat betekent dat alle RGB-strips tegelijk worden aangestuurd en er 3 PWM-pinnen nodig zijn (één voor elke kleur). In de toekomst wil ik elk van mijn vier RGB-strips kunnen bedienen. Dat betekent 4*3=12 PWM-pinnen (en waarschijnlijk een Arduino Mega). Oké, tijd voor wat schema's! Dit (zie afbeelding) is een basisweergave van het circuit (zal binnenkort een mooiere maken). De capacitieve sensoren worden ook meegeleverd (groen gedeelte). In principe zijn er drie componenten die moeten worden uitgelegd: - FETDit is de versterker waar ik het over had. Het heeft een poort, een bron en een afvoer. Het versterkt de zintuigen een kleine stroom op de poort (aangesloten op de Arduino) en opent de weg voor de RGB-strip die op 12 volt wordt aangedreven. Source moet op +12V staan, drain op GND (Ground). Controleer het specificatieblad van uw FET voor de exacte pinout. Elk RGB-kanaal moet voor zijn eigen FET worden geplaatst. In die zin gedraagt het zich als een Arduino-gestuurde schakelaar.- RGB-strip Deze 12 volt RGB-strip is van het type common anode (+). Dit betekent dat de gemeenschappelijke draad moet worden aangesloten op +12V en dat de stroom door elk van de afzonderlijke kleurkanalen moet worden gezakt. De strip heeft weerstanden, dus maak je daar geen zorgen over!- Weerstanden Drie 10k-weerstanden zorgen ervoor dat de FET niet wordt ingeschakeld als ze niet zouden moeten worden ingeschakeld. Drie andere zullen de maximale stroom beperken die de FET zal afvoeren. De bovenste drie weerstanden zitten al in de RGB-strip. Ik heb USB-kabels aan de RGB-strips gesoldeerd, zodat ik ze eenvoudig modulair kan aansluiten. Stekkers van een oude hub worden op mijn breadboard geplaatst. Gebruik een oude computervoeding voor sap, 12V voor het voeden van de RGB-strip en eventueel 5V voor het circuit als je wilt dat het zonder de USB-kabel werkt.

Stap 5: Stemmingslicht - Code & Controle

Het sfeerlicht wordt aangestuurd door de capacitieve sensoren. Voorlopig heb ik alleen sensoren 2 & 3 geprogrammeerd voor kleurverandering. De andere sensoren hebben nog geen functie. Hier is de code: --- Arduino Stemmingsbesturingscode --- #include const boolean invert = true;const long timeout = 10000;// Capacitieve sensorverklaringCapSense In1 = CapSense(2, 4); // 2M weerstand tussen pinnen 4 & 2, pin 2 is sensorpin, draad toevoegen, foilCapSense In2 = CapSense (2, 7); // 2M weerstand tussen pinnen 4 & 6, pin 6 is sensorpin, draad toevoegen, foilCapSense In3 = CapSense (2, 8); // 2M weerstand tussen pinnen 4 en 8, pin 8 is sensorpin, draad toevoegen, foilCapSense In4 = CapSense (2, 12); // 2M weerstand tussen pinnen 4 & 8, pin 8 is sensorpin, draad toevoegen, foilCapSense In5 = CapSense (2, 13); // 2M weerstand tussen pinnen 4 & 8, pin 8 is sensorpin, draad toevoegen, folie// PWM Pinverklaringenint PinR1 = 3;int PinG1 = 5;int PinB1 = 6;// Andere variabelenint Color1 = 128; // begin met een rode kleurint Helderheid1 = 255; // begin bij volledige helderheidint RedValue1, GreenValue1, BlueValue1; // De RGB-componenten ongeldig setup () {// set sensor time-outwaarden In1.set_CS_AutocaL_Millis (time-out); In2.set_CS_AutocaL_Millis (time-out); In3.set_CS_AutocaL_Millis (time-out); In4.set_CS_AutocaL_Millis (time-out); In5.set_CS_AutocaL_Millis(time-out);}void loop() { lange start = millis(); lang totaal1 = In1.capSense (30); lang totaal2 = In2.capSense (30); lang totaal3 = In3.capSense (30); lang totaal4 = In4.capSense (30); lang totaal5 = In5.capSense (30); if (totaal2 > 150) { Color1++; // verhoog de kleur if (Color1> 255) {// Color1 = 0; } } else if (totaal3 > 200) { Color1--; // verlaag de kleur if (Color1 <0) {// Color1 = 255; } // converteer tint naar rgb hueToRGB (Color1, Brightness1); // schrijf kleuren naar PWM-pinnen analogWrite (PinR1, RedValue1); analogWrite(PinG1, GreenValue1); analogWrite(PinB1, BlueValue1);}// functie om een kleur om te zetten in de rode, groene en blauwe componenten.void hueToRGB(int hue, int helderheid){ unsigned int scaledHue = (hue * 6); unsigned int segment = scaledHue / 256; // segment 0 tot 5 rond het kleurenwiel unsigned int segmentOffset = scaledHue - (segment * 256); // positie binnen het segment unsigned int compliment = 0; unsigned int prev = (helderheid * (255 - segmentOffset)) / 256; unsigned int next = (helderheid * segmentOffset) / 256; if (omkeren) { helderheid = 255-helderheid; compliment = 255; vorige = 255-vorige; volgende = 255-volgende; } switch (segment) { case 0: // rood RedValue1 = helderheid; GreenValue1 = volgende; BlueValue1 = compliment; pauze; geval 1: // geel RedValue1 = vorige; GreenValue1 = helderheid; BlueValue1 = compliment; pauze; geval 2: // groen RedValue1 = compliment; GreenValue1 = helderheid; BlueValue1 = volgende; pauze; geval 3: // cyaan RedValue1 = compliment; Groene Waarde1 = vorige; BlueValue1 = helderheid; pauze; geval 4: // blauw RedValue1 = volgende; GreenValue1 = compliment; BlueValue1 = helderheid; pauze; geval 5: // magenta standaard: RedValue1 = helderheid; GreenValue1 = compliment; BlueValue1 = vorige; pauze; }}--- EINDE ---

Stap 6: Ambi Light - Arduino-kant

Het zou natuurlijk helemaal gaaf zijn om het sfeerlicht vanaf je computer te kunnen bedienen. Bijvoorbeeld om een ambilight of een soundgestuurde disco te creëren. Deze sectie concentreert zich op het ambilight-gedeelte, in de toekomst zal ik meer functionaliteit toevoegen. Welnu, er is geen extra circuit omdat het allemaal beschikbaar is in de Arduino. Wat we gaan gebruiken zijn de seriële communicatiemogelijkheden en wat 'Processing 1.0'-software. Sluit je arduino aan op je computer via een USB-kabel (als je er schetsen naar uploadt, is dat al het geval). Voor de arduino moet je wel wat extra code toevoegen voor seriële communicatie. De code schakelt over naar de luistermodus, waarbij de capacitieve sensoren worden uitgeschakeld zolang deze RGB-waarden van de computer ontvangt. Het stelt vervolgens de RGB-waarden in op de PWM-pinnen. Dit is voorlopig mijn laatste code, controleer zelf de wijzigingen:--- Arduino Ambilight-code ---#include const boolean invert = true;const long timeout = 10000;long commStart = 0;char val;// Capacitieve sensordeclaratieCapSense In1 = CapSense(2, 4); // 2M weerstand tussen pinnen 4 & 2, pin 2 is sensorpin, draad toevoegen, foilCapSense In2 = CapSense (2, 7); // 2M weerstand tussen pinnen 4 & 6, pin 6 is sensorpin, draad toevoegen, foilCapSense In3 = CapSense (2, 8); // 2M weerstand tussen pinnen 4 & 8, pin 8 is sensorpin, draad toevoegen, foilCapSense In4 = CapSense (2, 12); // 2M weerstand tussen pinnen 4 & 8, pin 8 is sensorpin, draad toevoegen, foilCapSense In5 = CapSense (2, 13); // 2M weerstand tussen pinnen 4 & 8, pin 8 is sensorpin, draad toevoegen, folie// PWM Pinverklaringenint PinR1 = 3;int PinG1 = 5;int PinB1 = 6;// Andere variabelenint Color1 = 128; // begin met een rode kleurint Helderheid1 = 255; // begin bij volledige helderheidint RedValue1, GreenValue1, BlueValue1; // De RGB-componenten ongeldig setup () { Serial.begin (9600); // start seriële communicatie// stel time-outwaarden van de sensor in In1.set_CS_AutocaL_Millis (time-out); In2.set_CS_AutocaL_Millis (time-out); In3.set_CS_AutocaL_Millis (time-out); In4.set_CS_AutocaL_Millis (time-out); In5.set_CS_AutocaL_Millis(time-out);}void loop() { lange start = millis(); lang totaal1 = In1.capSense (30); lang totaal2 = In2.capSense (30); lang totaal3 = In3.capSense (30); lang totaal4 = In4.capSense (30); lang totaal5 = In5.capSense (30); if (Serial.available()) { // Als er gegevens beschikbaar zijn om te lezen, val = Serial.read(); // lees het en sla het op in val commStart = millis(); if (val == 'S') { //Als start char is ontvangen, while (!Serial.available()) {} //Wacht tot de volgende waarde. RedValue1 = Serieel.lezen(); //Zodra beschikbaar, toewijzen. while (!Serial.available()) {} // Hetzelfde als hierboven. GreenValue1 = Serieel.lezen(); while (!Serial.available()) {} BlueValue1 = Serial.read(); } Serial.print(RedValue1); Serial.print(GreenValue1); Serial.println(BlueValue1); } else if ((millis() - commStart) > 1000) { if (total2 > 150) { Color1++; // verhoog de kleur if (Color1> 255) {// Color1 = 0; } } else if (totaal3 > 200) { Color1--; // verlaag de kleur if (Color1 <0) {// Color1 = 255; } } hueToRGB(Kleur1, Helderheid1); } analogWrite(PinR1, RedValue1); analogWrite(PinG1, GreenValue1); analogWrite(PinB1, BlueValue1);}// functie om een kleur om te zetten in de rode, groene en blauwe componenten.void hueToRGB(int hue, int helderheid){ unsigned int scaledHue = (hue * 6); unsigned int segment = scaledHue / 256; // segment 0 tot 5 rond het kleurenwiel unsigned int segmentOffset = scaledHue - (segment * 256); // positie binnen het segment unsigned int compliment = 0; unsigned int prev = (helderheid * (255 - segmentOffset)) / 256; unsigned int next = (helderheid * segmentOffset) / 256; if (omkeren) { helderheid = 255-helderheid; compliment = 255; vorige = 255-vorige; volgende = 255-volgende; } switch (segment) { case 0: // rood RedValue1 = helderheid; GreenValue1 = volgende; BlueValue1 = compliment; pauze; geval 1: // geel RedValue1 = vorige; GreenValue1 = helderheid; BlueValue1 = compliment; pauze; geval 2: // groen RedValue1 = compliment; GreenValue1 = helderheid; BlueValue1 = volgende; pauze; geval 3: // cyaan RedValue1 = compliment; Groene Waarde1 = vorige; BlueValue1 = helderheid; pauze; geval 4: // blauw RedValue1 = volgende; GreenValue1 = compliment; BlueValue1 = helderheid; pauze; geval 5: // magenta standaard: RedValue1 = helderheid; GreenValue1 = compliment; BlueValue1 = vorige; pauze; }}--- EINDE ---

Stap 7: Ambi Light - computerzijde

Aan de zijkant van de computer wordt een Processing 1.0-schets uitgevoerd, zie processing.org. Dit kleine (enigszins rommelige) programma berekent op elk moment de gemiddelde schermkleur en stuurt deze naar de seriële poort. Het is tot nu toe erg basic en kan wat aanpassingen gebruiken, maar het werkt erg goed! Ik zal het in de toekomst bijwerken voor meerdere afzonderlijke RGB-strips en schermsecties. Dat zou je ook zelf kunnen doen, de taal is vrij eenvoudig. Hier is de 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); //grootte (scherm.breedte, scherm.hoogte); // Druk een lijst af van de seriële poorten, voor foutopsporingsdoeleinden: println(Serial.list()); // Ik weet dat de eerste poort in de seriële lijst op mijn mac // altijd mijn FTDI-adapter is, dus ik open Serial.list()[0]. // Op Windows-machines opent dit over het algemeen COM1. // Open de poort die je gebruikt. String portName = Serial.list()[0]; myPort = new Serial(this, portName, 9600);}void draw () { //image(screenShot, 0, 0, width, height); screenShot = getScreen(); kleur kleur = kleur(0, 0, 0); kleur = kleur (screenShot); //myPort.write(int(rood(kleur))+', '+int(groen(kleur))+', '+int(blauw(kleur))+13); //mijnPort.write(int(rood(kleur))); //mijnPort.write(', '); //myPort.write(int(groen(kleur))); //mijnPort.write(', '); //myPort.write(int(blauw(kleur))); //mijnPort.write(13); vulling(kleur); rect(30, 20, 55, 55);}kleur kleur (PImage img) { int cols = (img.width); int rijen = (img.hoogte); int dimensie = (img.breedte*img.hoogte); int r = 0; intg = 0; intb = 0; img.loadPixels();// Ga elke pixel langs (dimensie)for (int i = 0; i < (dimensie/2); i++) { r = r + ((img.pixels >> 16) & 0xFF); g = g + ((img.pixels >> 8) & 0xFF); b = b + (img.pixels & 0xFF);}int mean_r = r/(dimensie/2);int mean_g = g/(dimensie/2);int mean_b = b/(dimensie/2);kleur mean_clr = kleur (mean_r, mean_g, mean_b); mijnPort.write('S'); myPort.write(mean_r); myPort.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(); Rechthoekgrenzen = nieuwe Rectangle(0, 0, mode.getWidth(), mode.getHeight()); BufferedImage desktop = nieuw BufferedImage(mode.getWidth(), mode.getHeight(), BufferedImage. TYPE_INT_RGB); probeer {desktop = nieuwe Robot (gs [0]).createScreenCapture (grenzen); } catch (AWTException e) { System.err.println ("Schermopname mislukt."); } return (nieuwe PImage(desktop));}--- END ---

Stap 8: Resultaat

En dit is het resultaat, het zit eigenlijk aan de onderkant van mijn bed. Ik moet de doek nog vervangen, dit zal het licht meer verspreiden. Daarover binnenkort meer foto's. Ik hoop dat je dit instructable leuk vindt en ik hoop ook dat het een basis is voor je eigen creativiteit. Vanwege tijdgebrek heb ik het heel snel geschreven. Je moet misschien wat basiskennis van arduino / elektronica hebben om het te begrijpen, maar ik ben van plan het in de toekomst bij te werken als het goed wordt ontvangen.