Hallo,

Ik heb 24 RGB LEDs welke ik aan wil sturen met een AVR uC. De LEDs zitten steeds ongeveer 10 cm van elkaar verwijderd. Hiervoor maak ik gebruik van de welbekende 74HC595 portexpanders. Ik had de volgende layout in gedachten:

- Q0: LED1 rood
- Q1: LED1 groen
- Q2: LED1 blauw
- Q3: n.c.
- Q4: LED2 rood
- Q5: LED2 groen
- Q6: LED2 blauw
- Q7: n.c.

zo kan ik met 1 HC595 2 LEDs aansturen.

De hardware heb ik getest op breadboard en werkt prima. Echter bij het schrijven van de code liep ik tegen een paar problemen aan. Ik zou alle LEDs op 50Hz willen laten PWM'en, regelbaar in stappen van 100. Tot zover theoretisch geen probleem.

Omdat alle 595's in serie gekoppeld zijn, moet ik dus in totaal een string uitsturen van 96 bytes. Elke LED heeft 4 bytes nodig:
B3 - B2 - B1 - B0
dummy - blauw - groen - rood

Om een redelijk constante tijdbasis aan te houden, maak ik gebruik van een interrupt. Deze heb ik afgesteld op 8kHz, omdat dit makkelijk te realiseren was met dividers en prescalers.

Voor het uitsturen van de strings heb ik volgende code geschreven. String_Out(); wordt in de ISR aangeroepen, verder gebeurt er niks in de ISR.

///////////////////////////////////////////////////////////////////////////////
// Data output

void String_Out(void)
{

	//For each string in the array
	for(chanOut=0;chanOut<NUMCHAN;chanOut++)
	{
		//Timer counts from 0 to 99
		//If the value of the color is greater than the timer value
		//make the output high, else make the output low
		if (string[chanOut].red > string[chanOut].timer)
		{
			Data_High();
		} else {
			Data_Low();
		}
	
		if (string[chanOut].green > string[chanOut].timer)
		{
			Data_High();
		} else {
			Data_Low();
		}
	
		if (string[chanOut].blue > string[chanOut].timer)
		{
			Data_High();
		} else {
			Data_Low();
		}

		Data_Dummy();
		//Rise timer value by 1
		string[chanOut].timer++;

		//Reset timer if value is 100
		if (string[chanOut].timer == 100)
		{
			string[chanOut].timer = 0;
		}
	}

	//When all data is transmitted, send enable pulse
	//to copy data from register to flipflop
	EN_Pulse();
}

///////////////////////////////////////////////////////////////////////////////
// Data high
void Data_High(void)
{
	//Set data output on PORTD to HIGH, then give CLK pulse
	PORT_SR |= DATA_OUT;
	CLK_Pulse();
}

///////////////////////////////////////////////////////////////////////////////
// Data low
void Data_Low(void)
{
	//Set data output on PORTD to LOW, then give CLK pulse
	PORT_SR &= ~DATA_OUT;
	CLK_Pulse();
}

///////////////////////////////////////////////////////////////////////////////
// Data low
void Data_Dummy(void)
{
	//Give CLK pulse, independent of Data value
	CLK_Pulse();
}

///////////////////////////////////////////////////////////////////////////////
// Clock pulse
void CLK_Pulse(void)
{
	//Set CLK to HIGH, then set CLK to LOW
	PORT_SR |= CLK_OUT;
	PORT_SR &= ~CLK_OUT;
}

///////////////////////////////////////////////////////////////////////////////
// Enable
void EN_Pulse(void)
{
	//Set EN to HIGH, then set EN to LOW
	PORT_SR |= EN_OUT;
	PORT_SR &= ~EN_OUT;
}

Kleine toelichting:
string[] is een struct array, met als members .Red (voor de rode led), .Blue, .Green en .Timer
De constant NUMCHAN heb ik in een headerfile gedefinieerd op 24 (voor het aantal kanalen/LEDs)

Nu is mij op school altijd geleerd dat ik in een interrupt beperkt moet blijven met mijn code en als ik naar mijn function kijk is deze behoorlijk groot. Daarnaast zie ik een LED op 50% knipperen als ik NUMCHAN groter maak, wat betekend dat er teveel code wordt uitgevoerd in een ISR.

Ik zou graag jullie kijk op dit probleem willen. Wellicht dat iemand al eens tegen eenzelfde soort probleem is aangelopen? Misschien zijn er andere ideeën hoe ik het op zou kunnen lossen?

Wat is precies je probleem, want dat is me niet helemaal duidelijk uit je post.

Toch al een paar suggesties:
- Haal de "timer" uit de struct en maak er een aparte globale variabele van. Je tijdsbasis is toch altijd dezelfde.
- Doe het inshiften van de data niet in de interrupt routine. Je doet dit in je main loop en in de timer interrupt puls je dan de latch lijn. Op die manier is er ook geen variatie in de tijd afhankelijk van welke code uitgevoerd wordt.
- Ik weet niet of je deze vrij hebt, maar je kan de SPI uitgang gebruiken om wat resources vrij te maken. Je kan dan sneller alles in de *595's zetten.

Als je interrupt routine echt te traag is (wat mij zou verbazen, tenzij je AVR op een hele lage frequentie draait, dan is de enige oplossing de update frequentie te verlagen.

Het probleem is dat het in mijn ogen niet echt efficiënte code is, maar ik weet niet hoe het beter kan.

AVR te traag?

24 RGB LED's = 72 PWM kanalen. Heel erg veel voor een AVR. In de application note van atmel hebben ze het over tot iets van 24 kanalen en dan kan je al weinig anders doen. Dat is wel van 0-255 ipv van 0-99 maar dan zou ik dus hooguit 60 kanalen max verwachten ipv. 72 kanalen.

Is een TLC5940 niet een beter idee? 2 chips en je hebt 32 kanalen.

Lijkt mij op zich geen probleem, als je PWM't met stappen op 8Khz met een AVR met een kristal van 16 Mhz, kan je 2000 instructies per stap uitvoeren (zo'n 25 instructies per kanaal).

Ik ga wel akkoord dat de TLC5940 een mooiere oplossing is.

@Nixk-89: de code op zich lijkt niet zo slecht, maar zoals ik zei zou ik het shiften zelf niet in de interrupt doen, enkel de "EN_Pulse()"

Dat zijn dan wel 25 assembler instructies, dus niet de instructies van de hogere programmeertaal.

Aangezien er per RGB-led ook een dummy kanaal wordt gestuurd, komt het aantal te sturen kanalen op 96. Dat is wel ver boven de specificaties van de application note (zelfs het verschil 100 of 256 stappen meegerekend).

Afhankelijk van de toepassing is 50hz waarschijnlijk te laag voor leds. Ik heb verschillende matig ontworpen led-verlichting gezien die hinderlijk knippert, zeker tot 100hz is het erg storend.

De aangedragen TLC5940 is dan een betere oplossing. De prijs en verkrijgbaarheid valt me echter tegen. Ik ben zelf recentelijk de PCA9635PW tegen gekomen. Onder andere verkrijgbaar bij SMD shop (productlink). Ervaringen heb ik er nog niet mee, moet nog beginnen aan het project. ;)

(edit) Zowel de TLC5940 als PCA9635PW zijn 16 kanaals led-drivers, dus heb je er 5 nodig voor 24 RGB-leds. (Ik weet niet hoe LED-Maniak bij 2 chips komt...)

Op 20 maart 2010 14:05:45 schreef LED-Maniak:
24 RGB LED's = 72 PWM kanalen. (...) 2 chips en je hebt 32 kanalen.

[Bericht gewijzigd door ThaTweety op (16%)]

Ik heb eens gekeken naar de 5940 en dat lijkt me idd een betere oplossing, vooral omdat adressering een stuk makkelijker kan. Als ik van 1 LED de kleur/helderheid wil veranderen hoef ik niet de hele string van 96 bits opnieuw uit te sturen.

Daarnaast kan ik met een 5940 tot 4096 stappen instellen, wat erg handig is aangezien de intensiteit van het licht meestal niet lineair is aan de stroom (c.q. duty cycle).

In de datasheet staat trouwens dat de chip te leveren is in NT package, maar op het internet kan ik daar geen informatie over vinden. Enig idee hoe zo'n chip eruit ziet?

Ik heb hem trouwens wel gevonden op samenkopen.net, zowel in NT als in PWP package.

Op 21 maart 2010 10:23:20 schreef ThaTweety:
(Ik weet niet hoe LED-Maniak bij 2 chips komt...)
[...]

Precies zoals er staat.. Je hebt 72 kanalen nodig maar 2 chips zijn al 32 kanalen.

Op 21 maart 2010 11:42:33 schreef Nixk-89:
Ik heb eens gekeken naar de 5940 en dat lijkt me idd een betere oplossing, vooral omdat adressering een stuk makkelijker kan. Als ik van 1 LED de kleur/helderheid wil veranderen hoef ik niet de hele string van 96 bits opnieuw uit te sturen.

Daarnaast kan ik met een 5940 tot 4096 stappen instellen, wat erg handig is aangezien de intensiteit van het licht meestal niet lineair is aan de stroom (c.q. duty cycle).

In de datasheet staat trouwens dat de chip te leveren is in NT package, maar op het internet kan ik daar geen informatie over vinden. Enig idee hoe zo'n chip eruit ziet?

Ik heb hem trouwens wel gevonden op samenkopen.net, zowel in NT als in PWP package.

Ik heb ze hier draaien, van samenkopen gehaald. Is gewoon een DIP package. Je moet echter wel continue alle waardes shiften. Dit kan echter op tot ik dacht 30MHz dus SPI tijd kost vrijwel niets. Ik klok ze dan ook op de max dat de avr aan kan(geen prescale en SPI2X).