RGB led aansturen

>>2 PWM kanalen tegelijk werken niet.
2 hardware kanalen wel maar die heeft de 628A niet.

>>Moet ik dan met hardwarematige pwm en softwarematige pwm door elkaar werken?
das een mogelijkheid, of je gebruikt een 7x7 die heeft 3 harde pwm kanalen. of een "simpel" rgb stroombronnetje met selecter.

>>2 PWM kanalen tegelijk werken niet.

Ik kan op 3 kanalen pwmen

Ff als test op 6 kanalen geprobeerd, maar dan verslikt de pic zich. (misschien dat met een 20 Mhz kristalletje het wel kan)

>>Moet ik dan met hardwarematige pwm en softwarematige pwm door elkaar werken?

Dan zou je nog steeds 1 kanaal te kort komen.

Ik heb zelf als basis de beroemde programmeerbare rgb led van william gebruikt. Een paar mosfets erachter met ledstrips van niels, werkt geweldig.

http://home.versatel.nl/edithenwilliam/william/rgbled.htm

Die site ken ik. Ik verwerk m'n led in een toepassing. Maar hoe gebruik je 3 pwm kanalen tegelijk?
Bij mij gaan ze om en om, dan zie ik dus duidelijk 2 kleuren knipperen.

@TJ,

ik heb ook zoiets gebouwd, als je het volgens deze manier doet, ziet het er nog wel leuk uit:

blauwopkomend
rooddalend
groenopkomend
blauwdalend
roodoppkomend
groendalend

En alweer het bekende probleem bij de uC basic varianten: als het niet met de ingebouwde functies werkt (die op zijn best "bagger" zijn), is het gelijk "onmogelijk".

Voor LEDs hoef je niet eens snel te PWM'en. Op 400Hz (wat al veel meer is dan strikt noodzakelijk) kun zonder al te veel moeite wel 8 kanalen 8-bits PWMem, als je het gewoon zelf schrijft in C en/of ASM. Gebruik een timer interrupt, in combinatie met een beetje slimmigheid in de interrupt service routine. Je hebt dan maar een timer frequentie van zo'n 100kHz nodig, zodat de ISR iets minder dan 200 cycles mag duren, als je de controller klokt op 20MHz.

Het mooiste kun je je RGB leds met een sinus aansturen, aangezien het verloop van de sterkte niet linair is.

Ik geloof dat AN1074 van microchip daar zelfs ASM code voor heeft, met software pwm.

Doe hetzelfde in een simpel pic'tje in C, lookup table met de waardes in, werkt prima op een klok van 1 mhz, 3 kanalen.

Got it,
Ik was vergeten te vertellen dat ik gebruik maak v/d interne oscillator, op 4MHz.
Heb er nu een 20MHz kristal aanhangen, nu lijkt het goed te werken.

Bedankt voor de info jongens

Het werkt niet goed, het gaat alleen te snel om te zien dat het niet werkt.

PWM is een basic functie die een pulsen trein maakt. Je geeft de frequentie, duty en aantal pulsen op. In die tijd kan je niks anders doen. Daarom kan je dus ook niet 2 pwm's te gelijk doen.

Wat jij wilt hebben is een snelle for loop waar de juiste poorten hoog /laag gemaakt worden.

for(x=0;x<255;x++){
  if(x>duty_rood)
     led_rood = 1;
  else
     led_rood = 0;
}

Zoiets, maar dan voor al je kleuren.

Maar dan zit je nog steeds met het probleem dat je uc niks anders kan doen. Daarom vervang je de for loop door interrupts van een timer. Elke interrupt laat je x met 1 verhogen, in je main ga je dan de ledjes doen.

Ik heb zelf de software van william aangepast en uitgebereid.
Ik zal vanavond even kijken wat ik precies heb gedaan. Ik heb er een stuk inzitten waarbij alle 3 de kleuren tegelijk opkomen en een aantal stukjes 2 kleuren tegelijk.
Op het oog gaat dit uitstekend, nu moet ik wel bij zeggen, dat de pic alleen maar de moodlight doet. Ik kan mij voorstellen dat er geen tijd meer is voor andere instructies. (vandaar dat meer dan 3 kanalen niet werken)
zowiezo hou ik dan weinig ruimte voor andere instructies over.

Je kunt vrij gemakkelijk uitrekenen of meten hoeveel processortijd je nog over hebt. Met een profiler zie je direct hoeveel cycles je ISR nodig heeft, en je weet de frequentie van de interrupt.

Vrije processortijd meten is ook simpel, door in de idle loop een pinnetje te toggelen, eventueel in combinatie met een loze loop, en daar een frequentieteller aan te hangen.

Zoiets zou je volgens mij best in assembler programmeren in plaats van met hogere programmeertalen zoals Basic.

In assembler zou je makkelijk 32 software PWM kanalen kunnen maken als je dat zou willen. Ik geloof dat een tijd terug iemand er 64 had gemaakt met een simpele PIC en een paar schuifregisters. Waren ook inkoopacties voor.

In C kan dat ook prima hoor, als je een beetje begrijpt wat de compiler voor ASM code genereert voor een gegeven stukje C code.

Meer kanalen kan op zich wel, maar het wordt lastig als je veel kanalen wilt gebruiken, en een hoge frequentie, en een hoge resolutie.

De simpelste methode (die ik ook overal terug zie) is een teller te vergelijken met de PWM waarde voor elk kanaal, en afhankelijk van het resultaat de uitgang aan of uit te zetten. Dit kost dus een vergelijking met een branch instructie per kanaal, en op die manier kom je al snel in de problemen met het aantal beschikbare clockcycles.

Wat ik in het verleden wel eens heb gedaan voor zo'n toepassing, is een tabel maken met de intervallen tussen de in- en uitschakelmomenten van de verschillende kanalen. Je stelt dan steeds een timer in voor de tijd tot de eerste volgende overgang van een van de kanalen, waardoor je dus op elke timer interrupt een nieuw bitpatroon naar de uitgangen schrijft. Op die manier kun je met heel weinig processortijd een heleboel PWM signalen genereren, met een paar beperkingen. Als de flanken er dicht achter elkaar komen, kun je kleine afwijkingen krijgen, maar dat gebeurd alleen op frequenties en resoluties die op de standaard methode lang niet haalbaar zijn. Daarbij moet je natuurlijk wel bij elke verandering van een enkel kanaal de tabel gedeeltelijk of helemaal opnieuw berekenen, maar over het algemeen veranderen de PWM waarden maar erg weinig in vergelijking tot de PWM frequentie.

Daar hebben we wel een probleem.
Op het moment dat ik aan het PWMen ben (en dat is hij altijd, aangezien het een led is voor backlight)
kan ik niks meer doen..

e/ ga even aan de slag met een 16F876A, misschien zijn 2 HPWM poorten genoeg.

[Bericht gewijzigd door Technojunk op vrijdag 5 juni 2009 17:42:35 (20%)]

wil je zoiets maken als bij de display van de kif voeding. Die verkleurd ook.

-=diepe zucht=-

Je kan zeer zeker nog van alles doen terwijl je aan het PWM'en bent, als je de software PWM niet helemaal op een hersendode manier doet, zoals dat in de PICBasic library gedaan wordt.

Dit is nu precies wat ik altijd probeer duidelijk te maken, wat er naar mijn idee mis is met de Basic talen voor de microcontrollers, en indirect ook met de bijbehorende programmeurs.

Met die Basic talen hebben mensen vaak geen flauw idee wat ze aan het doen zijn, en als de standaard functies niet doen wat ze willen, zijn ze reddeloos verloren. Daarbij is het naar mijn idee gewoon not done om zulke functies blocking te maken in een microcontroller, aangezien die dingen meestal een aantal verschillende taken tegelijk moeten kunnen doen.

Flikker die Basic compiler toch in de bittenbak, en begin met C. Zo moeilijk is dat echt niet. In het begin zal het best een beetje frustrerend zijn, omdat je opeens alles zelf moet doen, in plaats van standaard libraries te gebruiken, maar je kunt er uiteindelijk zo veel meer mee, en dan weet je ook precies wat die controller aan het doen is.

@ Sparky: dat geldt niet voor iedereen. Ik ben ook met C begonnen maar het wil voor geen meter. Geef mij maar ASM.

@TJ: Als je het bij basic+ een pic wil houden, pak dan een pic16F737, die heeft 3 HPWM kanalen. Hoef je alleen maar af en toe een nieuwe dutycycle-waarde naar toe te sturen.

Ik denk er volledig hetzelfde over als SparkyGSX. Schrijf je in c, dan ben je verplicht de datasheet te doorworstelen. Resultaat is dat je perfect weet wat kan en wat niet en in die basic talen leer je snel snel wat functies te gebruiken en klamp je je daaraan vast. Ik wil niet zeggen dat andere talen slechter zijn maar als je die functies nu eens laat vallen en ze zelf schrijft, kom je al een stuk verder en dat in elke taal.

Ok, toegegeven, bij ASM heb je wat dat betreft dezelfde voordelen als bij C, en waarschijnlijk nog wel wat sterker, omdat je echt alle instructies zelf schrijft.

Persoonlijk vind ik ASM te onoverzichtelijk en teveel werk, in ieder geval om hele programma's mee te schrijven. Af en toe programmeer ik ISR's e.d. in ASM, als het echt kritisch wordt, maar verder eigenlijk niet.

Voor de meeste mensen is C waarschijnlijk nog een stuk beter te begrijpen dan ASM, zeker als je alle Basic kent.

PIC op 20MHz, 5M instructies / seconde, tellertje van 255 in de interrupt, pwm van 100Hz geeft... +/-190 instructies maximaal per interrupt. Daar kan je zelfs in basic nog vrij vreemde dingen mee doen. Vooral als je wat inline asm gebruikt.

Mee eens, maar niet als je de ingebouwde blocking software PWM instructie wilt gebruiken. Je zult dan toch (wha! stel je voor!) moeten begrijpen / uitzoeken hoe interrupts en zo werken.

En als je dan toch inline ASM gaat gebruiken, waarom dan nog Basic?

De datasheet moet je toch altijd lezen als je met timers en interrupts gaan spelen. Toch?