RGB-Objektbeleuchtung

A.E. · Fr, 21.08.09, 22:15

Ich möchte euch heute mein Mini Projekt vorstellen.
Es ist ein Geschenk an meinen Onkel. Mit einem einfachem Programm. Für umfangreichere Programme sorgt er, porgrammierbegeistert ist er. Programmiert wird mit/für den ATtiny3213. Die Hardware hab ich für ihn aufgebaut.

Im Vorfeld schon mal das Endergebnis.

: PR

: PV

: PW

Was ich dafür gebraucht habe:

-Lochrasterplatine
-Widerstände
+Feste (R 150Ohm, G u.B 100Ohm )
+Einstellbare, um einen Individuelles Mischverhältnis zu bekommen (Jeweils max 500Ohm)
-LED Samsung SLSRGBW815TS
-Hohlbuchse
-Hohlbuchsenstecker
-Draht zum verbinden
-Lötkolben und Lot
-Holz und Acrylglas
-Alleskleber
-Säge
-Stemmeisen (im Notfall geht auch ein Messer)
-Acrylfarbe
-5V Steckernetzteil (es lagen aber 6,5V an)
=>Zwei Dioden zur Spannungsreduziereng

: Schaltplan

Unterhalb sieht man den umgedrehten Deckel. Ich habe dafür ein dünnes Brett genommen, welches ich mit der Dekopiersäge ausgeschnitten habe und anschließend mit einem Stemmeisen bearbeitet habe, damit der Deckel auf dem Gehäuse "einrastet". Um das Licht der LED besser zu zerstreuen, habe ich die Acrylglasplatte mit Schmirgelpapier angerauht und anschließend mit einem Universalkleber in den Deckel eingeklebt.
Als LED habe ich die Samsung SLSRGBW815TS genommen, schade dass Lumitronix diese oder eine vergleichbare LED nicht anbietet.

: Gehäuse offen

: Gehäuse geschlossen

Hier der Assembler Code von meinem einfachen Programm. Es ist eine unendliche Schleife ohne Möglichkeit mit das Programm im Betrieb zu verändern. (Außer mit dem Reset es von neuem beginnen zu lassen.) Die An-Zeit Intervalle sind bei allen Farben Gleich. Die Aus-Zeit Intervalle sind unterschiedlich, sodass nach einer gewissen Zeit Mischfarben entstehen. Allerdings laufen die Farben mit voller Spannung oder keiner Spannung, auch ohne schnelles ein-und ausschalten, sodass nur 7 Farben dargestellt werden können.

Fragen hierzu beantworte ich gerne. Allerdings ist das meine erstes Assembler Programm und somit mit viel Hilfe entstanden.

Code: Alles auswählen

.include "2313def.inc"
.def DunkelHellMerkerR=r16
.def DunkelHellMerkerG=r17
.def DunkelHellMerkerB=r18
.def zr0=r19
.def zr1=r20
.def temp=r21
.def ZaehlregisterRot=r22
.def ZaehlregisterGruen=r23
.def ZaehlregisterBlau=r24

.equ ZeitRotHell=100;100x100ms
.equ ZeitRotDunkel=80;8sec
.equ ZeitGruenHell=100;10sec
.equ ZeitGruenDunkel=60;6sec
.equ ZeitBlauHell=100;10sec
.equ ZeitBlauDunkel=40;4sec

.equ Rotleuchtet=$FF
.equ Gruenleuchtet=$FF
.equ Blauleuchtet=$FF
.equ Rotdunkel=$00
.equ Gruendunkel=$00
.equ Blaudunkel=$00


ldi temp, $FF
out ddrd, temp
ldi ZaehlregisterRot, ZeitRotHell

ldi ZaehlregisterGruen, ZeitGruenHell

ldi ZaehlregisterBlau, ZeitBlauHell

Farbschleife:
Rot:
dec ZaehlregisterRot
brne Gruen; Rotzeit noch nicht abgelaufen
;Rotzeit ist abgelaufen
cpi DunkelHellMerkerR, Rotleuchtet
breq RotDunkelSchalten
;zurzeit ist Rot dunkel, rot soll eingeschaltet 
;werden und Merker auf Rotleuchtet setzen
cbi portd, 0
ldi DunkelHellMerkerR, Rotleuchtet
ldi ZaehlregisterRot, ZeitRotHell
rjmp Gruen
RotDunkelSchalten:
sbi portd, 0
ldi DunkelHellMerkerR, RotDunkel
ldi ZaehlregisterRot, ZeitRotdunkel


Gruen:
dec ZaehlregisterGruen
brne Blau; Guenzeit noch nicht abgelaufen
;Guenzeit ist abgelaufen
cpi DunkelHellMerkerG, Gruenleuchtet
breq GuenDunkelSchalten
;zurzeit ist Guen dunkel, Guen soll eingeschaltet 
;werden und Merker auf Guenleuchtet setzen
cbi portd, 1
ldi DunkelHellMerkerG, Gruenleuchtet
ldi ZaehlregisterGruen, ZeitGruenHell
rjmp Blau
GuenDunkelSchalten:
sbi portd, 1
ldi DunkelHellMerkerG, GruenDunkel
ldi ZaehlregisterGruen, ZeitGruendunkel

Blau:
dec ZaehlregisterBlau
brne Zeitverheizen; Blauzeit noch nicht abgelaufen
;Blauzeit ist abgelaufen
cpi DunkelHellMerkerB, Blauleuchtet
breq BlauDunkelSchalten
;zurzeit ist Blau dunkel, blau soll eingeschaltet 
;werden und Merker auf Blauleuchtet setzen
cbi portd, 2
ldi DunkelHellMerkerB, Blauleuchtet
ldi ZaehlregisterBlau, ZeitBlauHell
rjmp Zeitverheizen
BlauDunkelSchalten:
sbi portd, 2
ldi DunkelHellMerkerB, BlauDunkel
ldi ZaehlregisterBlau, ZeitBlaudunkel


Zeitverheizen:
;sechzehn_bit_zaehler:; Unterprogramm das 2^16 no opperation Befehle ausführt
Schleifenbeginn:
;Verheizen von Zeit

nop
nop
nop


inc zr0
brne Schleifenbeginn
inc zr1
brne Schleifenbeginn
rjmp Farbschleife

Für die Farbtests habe ich einen Deoroller missbraucht. Ich hoffe es gefällt euch.

: W

: V

: T

: Ge

: B

: R

: Gr

Gruß A.E.

Larkin · Fr, 21.08.09, 22:39

Sehr schön geworden, die Samsung derzeit die absolut besten SMD LEDs für den Preis.

A.E. · Mo, 31.08.09, 15:22

Vielen Dank für dein Lob, freut mich zu hören, dass es dir gefällt. Bei meinem Onkel ist das Minigeschenk auch gut angekommen

Gruß A.E.

Achim H · Mo, 31.08.09, 15:48

OffTopic
Betrifft die Pyramide mit der Holographie-Weltkugel.

Ich habe mal irgendwo (schon ein paar Jährchen her) im Fernsehen gesehen, dass man sich seinen Kopf in einen Acryl-Block lasern lassen kann. Weiß zufälligerweise jemand, wer diesen Service anbietet?

mfg Achim

A.E. · Mo, 31.08.09, 16:13

Das habe ich gefunden. Ich hoffe es hilft dir weiter.

http://www.starglas.de/Scanner/scanner.html

Achim H · Mo, 31.08.09, 16:57

Ja, genau das meinte ich.

Vielen Dank!

A.E. · Sa, 20.02.10, 13:51

Da ich diese "RGB-Objektbeleuchtung" als Übung für mein Hauptprojekt verwende, welches aber schon seit langer Zeit nicht mehr verändert worden ist welches ich in C-Programmieren möchte, habe ich für mich selbst ebenfalls nochmal die Gleiche Schaltung mit der RGB-LED aufgebaut und in C ein etwas anspruchsvolleres Programm geschrieben. Nach ursprünglichen Schwierigkeiten macht das Programm nun was es tun soll. Vermutlich für die erfahrenen Programmierer nichts besonderes.
http://www.youtube.com/watch?v=AldZ646_isw

Nun fehlt nur noch ein gleichmäßiger Intensitätsanstieg der einzelnen Farbe. Versucht habe ich das indem ich den max Intensitätswert und den Intensitäswert der einzelnen Farbe als Exponenten von 2 ("2^x") benutzt habe. Dummerweise wird dann das Programm zu groß für den tiny2313 wenn man "viele" Intensitässufen haben möchte. Hat jemand eine passende Idee?

Gruß A.E.

Hier noch eine kleine Erklärung welche wichtigen Variablen was bedeuten.

Code: Alles auswählen

#include <avr/io.h>
#include <stdbool.h>
//#include <math.h>
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
// "FarbeUndZeit" dient zum einen dazu die Intensität der einzelnen Farben      //
// durch schnelles Ein und Ausschalten zu steuern welche auf eine max           //
// Intensität von "maxIntensi =..." betrieben werden können. Zum anderen soll   //
// die Zeit definiert werden wie lange die erzeugte Farbe (aus RGB) angezeigt   //
// werden soll ("Farbzeit = ...").                                              //
// Außerdem soll noch die Helligkeit exponential "gemacht" werden, um einen     //
//  gleichmäßigen Helligkeitsanstieg zu gewährleisten. ("visuelleIntensitaet"). // 
//                                                                              //
// "ZaehlRichtung" bestimmt, ob sich die Helligkeit verringen oder erhöhen soll.//
// "WarteZaehler" bestimmt ob der Step erreicht ist wenn ja wird der Zähler     //
// der einzelnen Farbe wieder auf 0 gesetzt.                                    //
// "IntensitaetVeraendern" erhöht oder vermindert den Intensitätswert der Einzelfarbe  //
// "main" soll vorher definierte bzw. eingegebene Werte an die Funktion         //
// übergeben.                                                                   //
//                                                                              //
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
/*int visuelleIntensitaet(int Vorgabe)
{
int visIntensitaet;
if(Vorgabe>10)
{visIntensitaet = 2 ^ Vorgabe;}
else{visIntensitaet= Vorgabe+1;}
return visIntensitaet; 
}*/
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
bool ZaehlRichtung(int Intensi, int maxIntensi, bool ZR)
{
  if(Intensi==maxIntensi) //Konflikt zwischen der zahl "RIntensi" und "RvH"
  {                    //im Unterprogramm wird "RvH" mit "maxIntensi" verglichen
  ZR = false;   //Helligkeit ist max nun soll nach unten gezählt werden
  }
  else
  {
  if(Intensi==0)
  ZR = true;  //Helligkeit ist min nun soll nach oben gezählt werden
  }
  return ZR;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int WarteZaehler(int WZ, int Step)
{
if(WZ==Step)
{
WZ=0;
}
else{WZ++;}
return WZ;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int IntensitaetVeraendern(bool ZR, int Intensi, int Step, int WZ)
{
if(ZR==true)
  {
  if(WZ == Step) //Nur erhöhen wenn Steps abgelaufen
   {
   Intensi++;
   }
  }
  else
  {
   if(WZ == Step)
   {
   Intensi--;
   }
  }
  return Intensi;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void FarbeUndZeit(int RIntensi, int GIntensi, int BIntensi, int Farbzeit,int maxIntensi)
{
int x=0, y=0, D=0x00; //"x" wird mit "maxIntensi" bzw die einzelne Farbe vergl.; "y" wird mit "Farbzeit" verlglichen 
do//Länge der (Sichtbaren) "Farbzeit" der einzelnen Farben 
{
y++;
do //Helligkeitssteuerung "Intensi"/Intensität
{
x++;
D=0x00;
 if(x>RIntensi) 
  {
  D |=(1<<PB0);
  }
 if(x>GIntensi)
  {
  D |=(1<<PB1);
  }
 if(x>BIntensi)
  {
  D |=(1<<PB2);
  }
 PORTD = D;
}while(x<maxIntensi);//Ende der Helligkeitssteuerung der einzelnen Farben
x=0;
}while(y<Farbzeit);
y=0;
return; //Zum Hauptprogramm zurück um eventuell neue Eingaben zu berücksichtigen 
}
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
int main()
{
int RIntensi=255, GIntensi = 1, BIntensi = 63; //Intensität;
int maxIntensi=255; // maxIntensi:  Helligkeitsstufen/Intensität
//int RvI=0, GvI=0, BvI=0; //Anpassung an die sichtbaren Helligkeitsstufen/Intensitätsstufen
bool ZRR=true, ZRG=true, ZRB=true; //Zählrichtung: true entspricht Vorwärts
int StepR = 9, StepG = 2, StepB = 5;//Soll jedes mal der Wert verändert werden? (bei "1" Ja!)
int RWZ=0, GWZ=0, BWZ=0; //WarteZähler der einzelnen Farben (hiermit wird der Step Verglichen)
int Farbzeit=4 ;//Leuchtdauer einer Farbkombination
bool endlos = false;
	/* Define pull-ups and set outputs high */
	PORTB = (1<<PB2)|(1<<PB1)|(1<<PB0); // Pull ups
	PORTA = (1<<PA2);
	DDRA = 0; //Reset auf Eingang setzten
	DDRB = 0; //Eingabetaster auf Eingang setzen
	DDRD = 0x07; //Ausgabe entspricht "1"
	PORTD = 0x07;
do
{
/*RvI = visuelleIntensitaet(RIntensi); //RvH entspricht Rot visuelle Helligkeit
GvI = visuelleIntensitaet(GIntensi);
BvI = visuelleIntensitaet(BIntensi);*/
FarbeUndZeit(RIntensi, GIntensi, BIntensi, Farbzeit, maxIntensi); //xIntensi wird noch ersetzt durch XvI

ZRR = ZaehlRichtung(RIntensi, maxIntensi, ZRR);
ZRG = ZaehlRichtung(GIntensi, maxIntensi, ZRG);
ZRB = ZaehlRichtung(BIntensi, maxIntensi, ZRB);

RIntensi = IntensitaetVeraendern(ZRR, RIntensi, StepR, RWZ);
GIntensi = IntensitaetVeraendern(ZRG, GIntensi, StepG, GWZ);
BIntensi = IntensitaetVeraendern(ZRB, BIntensi, StepB, BWZ);

RWZ = WarteZaehler(RWZ, StepR);
GWZ = WarteZaehler(GWZ, StepG);
BWZ = WarteZaehler(BWZ, StepB);
}while(endlos==false); //Vorerst Endlosschleife
return 0;
}