Oke, nu ik de externe interrupt van de PIC16f628 doorheb en een leuk programma heb geschreven voor een klein lichtcomputertje,ben ik beland waar ik al een tijd nieuwsgierig naar ben en dat is hoe ik een led kan laten faden.
Mijn bedoeling is om eerst gewoon 1 led te laten faden en dan vervolgens uit te breiden naar een RGB-led.
Ik weet (denk ik) hoe pulsbreedtemodulatie werkt alleen heb ik geen idee hoe ik dit moet realiseren met mijn PIC.
Ik heb natuurlijk al wat rondgesnuffeld op CO en internet maar dan krijg ik meteen geavanceerde voorbeelden waar ik niet veel wijzer van word.
Kan iemand mij een duw in de goede richting geven?

P.s: Ik programmeer in ASM, :)

Ik ken de PICs niet, maar er zijn 2 mogelijkheden: je doet het in hardware of je doet het in software.
Een aantal uCs heeft een PWM controller (soms meer) aan boord. Daarvan stel je de frequentie en de duty cycle in en "that's it". In software is het iets ingewikkelder, maar voor een LED goed te doen.

Voor de AVR heb ik ooit eens zo iets gemaakt met een timer. Op de overflow wordt in interrupt gegenereerd; de routine die hierachter hangt toggled de uitgang en set de timer opnieuw (met de waarde die bij die 'high' or 'low' periode hoort).

Kijk hier eens naar:

<EDIT>
http://home.versatel.nl/edithenwilliam/william.htm
<EDIT>

Misschien dat de asm file een beter beeld geeft van de PWM functie die ik heb gebruikt.

Op 31 januari 2005 13:15:54 schreef Willie Worteltje:
Kijk hier eens naar:

http://home.versatel.nl/edithenwilliam/

Misschien dat de asm file een beter beeld geeft van de PWM functie die ik heb gebruikt.

Deze had ik inderdaad al gezien alleen veel snap ik er niet van omdat het meteen zo uitgebreid is denk ik.
Waarvoor gebruik je trouwens die EEPROM?
En wat zijn macro's?
En wat doe je met: "include <P16F628.INC>"
Als het is wat ik denk dan doet mijn compiler (programma waar je de code in schrijft, toch?) dit al automatisch.

Ik meen me te herineren dat er in de data sheet van de 16f628 helemaal staat uitgelecht hoe je dat moet configureren.

[edit] idd op pagina 64 staat het.

[Bericht gewijzigd door dwar op ]

Uitleg macro's

Met macro's kun je een stukje code herhalen met variabelen.

de macro IRGRT register1,register2,label staat voor
If register1 > register 2 goto label

De code die gecompileerd wordt is echter ingewikkelder.
daarvoor heb ik die macro's geschreven om een beter overzicht voor mijzelf te creeeren.

Er gaat geen ruimte verloren omdat een macro pas wordt mee gecompileerd als deze is aangeroepen.

De EEPROM staat voor de interne EEPROM.

Deze is dus remanent maar kan dus zonder de uC te herproggen worden beschreven.

"include <P16F628.INC>" zorgt ervoor dat je 'symbolisch' kan aanroepen.

STATUS equ 03
PORTA equ 05
PORTB equ 06

vandaar.

succes.

Oke, dus als ik het goed begrijp moet ik de interne timer gebruiken en gebruik maken van de "timer overflow interrupt".
Is het gebruikelijk om de tijd van de timer als periodetijd te gebruiken en dan een andere teller te maken voor de duty cycle of is dat raar?
En bij welke frequentie kun je dit voor fading leds het beste doen zodat je een zichtbaar effect krijgt?

In kopieren en plakken ben je goed zo te zien ;)
http://www.circuitsonline.net/forum/view/17427/last
Maar kan iemand antwoord geven op mijn vragen?

Heej bnj,
Nog steeds bezig met die leds??? Okay voor de zoveelste keer zal ik het je nog een keer uitleggen!

Om te pwm-en heb je 2 tellers nodig die van 0 tot 255 tellen. Wat je doet is teller 1 vergelijken met de waarde uit teller 2. Als de waarde van teller 1 onder de waarde van teller 2 zit dan led uit en als teller 1 boven de waarde uit teller 2 zit dan led aan.
Door nu teller 2 te verhogen of verlagen kun je de duty cycle veranderen terwijl de frequentie gelijk blijft!

De lichtsterkte is inderdaad niet lineair maar je zou een een omrekeningstabel kunnen gebruiken die de niet lineariteit van de led opheft.

Simpel toch?

Veel succes (weer!)

Rik.

Op 2 februari 2005 17:07:39 schreef Rik_J:
Heej bnj,
Nog steeds bezig met die leds??? Okay voor de zoveelste keer zal ik het je nog een keer uitleggen!

*ZUCHT*

Door nu teller 2 te verhogen of verlagen kun je de duty cycle veranderen terwijl de frequentie gelijk blijft!

Oke, dus als ik het goed begrijp krijg je de periode dat hij hoog is nu aan het eind van je totale periode?
Ik zal het zo snel mogelijk gaan proberen!!

maakt nix uit natuurlijk of de aan periode aan het eind komt of aan het begin! De duty cycle blijft in alle twee de gevallen gelijk....

Inderdaad, laten we het maar bij een pic houden voorlopig.

Als eerste post van jou is dat best wel dom....
Hou het liever on topic.

hmm van mij krijg hij een kans als hij de termen uit kan leggen

[MOD-EDIT]

berichten van josvanmieghem verwijderd

[Bericht gewijzigd door Jonathan op ]

Zoiets wordt het dan:

main_loop	CALL	uit		;led uit
		CALL	wacht		;
		CALL	rood		;led aan
		CALL 	wacht2		;
		INCF	pwm_counter,1	;pwm-counter ophogen
		GOTO	main_loop	;herhalen


		;-------------------------------------------------------------
		;			Subroutine(s)
		;-------------------------------------------------------------


wacht		MOVLW	020h		;
		MOVWF	teller2		;laadt teller2 voor vertraging (anders niet zichtbaar)
next_teller2    MOVLW	0FFh		;
		MOVWF	teller		;laadt teller
		MOVF	pwm_counter,0	;zet pwm-counter in w
		SUBWF	teller,1	;trek de waarde van 'w', af van 'teller'
next_teller	DECFSZ	teller,1	;
		GOTO	next_teller	;
		DECFSZ	teller2,1	;
		GOTO	next_teller2	;
		RETURN			;
		

		MOVF	pwm_counter,0	;
		MOVWF	teller		; laadt teller met pwm-counter
next_teller_2	DECFSZ	teller,1	;
		GOTO 	next_teller_2	;
		RETURN			;


rood	MOVLW	80h	;
	MOVWF	PORTA	;
	RETURN

uit	CLRF	PORTA	;
	RETURN

Commentaar/suggesties zijn welkom!!

Voor wie geinteresseerd is, dat PDF-bestand staat hier:
http://engineering.dartmouth.edu/~engs031/hansen/demos/Agilent-LEDmatr…

@Bnj: je mainloop bestaat uit 4 calls:

CALL	uit		;led uit
CALL	wacht		;
CALL	rood		;led aan
CALL 	wacht2		;

Waar staat het label wacht2 ?

[Bericht gewijzigd door logic op ]

wacht2		MOVF	pwm_counter,0	;
		MOVWF	teller		; laadt teller met pwm-counter
next_teller_2	DECFSZ	teller,1	;
		GOTO 	next_teller_2	;
		RETURN			;

sorry, zo bedoel ik hem

Ok, ziet er goed uit.
Heb je 't al uitgeprobeerd in het echt?

Nog niet op deze manier. Maar waar ik eigenlijk benieuwd naar was is of je dit niet anders kan bouwen?
Het is wel kort genoeg maar volgens mij niet gebruikelijk om het zo te doen.
Ik heb vaker gehoord dat ze de timer gebruiken en dan een interrupt on overflow.
Weet jij hier iets van? en waarom ze dan daarvoor kiezen?

Je kan dit idd ook met een ingebouwde timer doen.
Je overhead wordt dan minder en de timing betrouwbaarder (= nauwkeuriger).

On interrupt: laad een nieuwe waarde in de timer en start de timer. That's it.
Terwijl de timer loopt, kan de PIC ondertussen gewoon andere dingen doen.
Nu niet: nu sta je in een lus met teller en teller2.

Als de timer afgelopen is, volgt er vanzelf een interrupt.
Dan doe je weer hetzelfde: timer laden en starten. (maar nu met een andere waarde)

De timing wordt nauwkeuriger opdat je de onnauwkeurugheid van GOTO-opdrachten niet hebt. (die GOTO's kosten ook tijd, moet je allemaal rekening mee houden) DECFSZ kost 1 instructie-cycle zonder skip, maar 2 met skip.

Als je een timer laat lopen en rustig de interrupt afwacht, dan heb je die kopzorgen niet.

loopt die interne timer niet veel te snel?(1 usec klokcycle)
Of gebruik je daarvoor die prescaler en zet je die dan maximaal 1:128? (1 stap in de timer = 128 klokcycles) toch?

[Bericht gewijzigd door Bnj op ]

Het maakt in principe niet uit hoe snel die timer loopt, want het gaat om de verhouding tussen aan-tijd en uit-tijd.

Als de timer 100 cycli loopt met de LED aan, en daarna 50 cycli met de LED uit, dan heb je een aan/uit verhouding van 100/50 (allebei delen door 50 -> 2/3 aan en 1/3 uit).

Als je een 16-bits timer hebt en die loopt 60.000 cycli met de LED aan en daarna 30.000 cycli met de LED uit, dan heb je ook 2/3 aan en 1/3 uit (allebei delen door 30.000)

In de praktijk komt er natuurlijk een aantal instructie-cycli bij om de timer te laden en te starten.
Als de timer dan extreem kort loopt, dan worden die extra instr.-cycli te lang in verhouding tot de looptijd van de timer.
Als je b.v 10 instructies nodig hebt om de timer te laden en te starten en terug te keren uit de interrupt-routine en de timer loopt vervolgens maar 4 cycli, dan raakt de verhouding natuurlijk helemaal zoek.

Op dit moment is mijn code als volgt:

main_loop	CALL	uit
		CALL	wacht
		CALL	rood
		CALL 	wacht2
		INCFSZ	pwm_counter,1
		GOTO	main_loop
		MOVLW	0FFh
		MOVWF	pwm_counter
main_loop_down	CALL	uit
		CALL 	wacht
		CALL	rood
		CALL 	wacht2
		DECFSZ	pwm_counter,1
		GOTO	main_loop_down
		CLRF	pwm_counter
		GOTO	main_loop

		;-------------------------------------------------------------
		;			Subroutine(s)
		;-------------------------------------------------------------


wacht		MOVLW	010h		;
		MOVWF	teller2		;laadt teller2 voor vertraging
next_teller2    MOVLW	0FFh		;
		MOVWF	teller		;laadt teller met 255
		MOVF	pwm_counter,0	;zet pwm-counter in w
		SUBWF	teller,1	;trek 'w' van 'teller' af
next_teller	DECFSZ	teller,1	;
		GOTO	next_teller	;
		DECFSZ	teller2,1	;
		GOTO	next_teller2	;
		RETURN			;


wacht2		MOVF	pwm_counter,0	;
		MOVWF	teller		; laadt teller met pwm-counter
next_teller_2	DECFSZ	teller,1	;
		GOTO 	next_teller_2	;
		RETURN			;


rood	MOVLW	80h	;
	MOVWF	PORTA	;
	RETURN

uit	CLRF	PORTA	;
	RETURN

De bedoeling van deze code is dat een led zich als volg gedraagt: fade-in-->fade-out-->fade-in, enz.
Alleen nu heb ik het probleem dat hij op zijn 'top' flitst en in zijn 'dal'ook. (voor de rest werkt hij wel)
Volgens mij zie ik iets over het hoofd, kan iemand helpen?