PIC16F84 // Multiplexing
Ik probeer wat te begrijpen van microcontrollers en heb zojuist wat simpele dingen gedaan (5 LEDs / segmenten display aansturen). Nu wil ik wel eens weten hoe multiplexing nou in elkaar steekt. De hardware kant begrijp ik al een beetje en ik heb een simpele schakeling gemaakt:

http://matthijs.servebeer.com/pics/schema.png
(op het laatst had ik geen zin meer in netjes ;))

Maar hoe stuur ik dit nu aan? PortA moet dus A0 en A1 gebruiken om te 'scannen' en PortB moet B4 en B5 gebruiken om de LED per kolom aan te sturen.

Hoe zorg ik dat de timing goed is (en dat er uberhaubt een timer werkt).
In welke taal is dit nu het makkelijkst, ASM?

Dit is volgens mij niet echt wat je noemt "multiplexen". Volgens mij wil je gewoon een LED-matrix aansturen.

Ik snap alleen niet helemaal wat je wilt. Je sluit sowieso 2 LEDs aan op 1 I/O-poort, dit gaat mis. Je I/O-poort kan maximaal 25mA leveren, dus...

Of wil je meerdere 7-segments-displays wilt aansturen? Laat effe weten wat je wilt, dat helpt wat makkelijker.

Toch niks mis mee, afwisselend maak je 10 en 11 laag. Of de ene kolom gaat aan, of de ander.
C of asm maakt niet veel uit, wel moet het een beetje snel ( 30 Hz minimaal). Wat ik altijd makkelijk vind is een timertje laten lopen, het timertje pollen, en als hij afloop of de een, of de ander aanzetten. Kan natuurlijk ook in een interupt routine.
Nog minder pinnetjes is als je de ledjes omgekeerd monteerd :
pin a hoog b laag : rij 1 aan.
pin b hoog a laag : rij 2 aan
bijde hoog ( of laag ) : uit.
Scheelt een pin.

Op 1 september 2004 12:59:52 schreef Sponcebert:
Toch niks mis mee, afwisselend maak je 10 en 11 laag. Of de ene kolom gaat aan, of de ander.

Juist, effe overheen gekeken..

Ik ben van plan om als begin project een LED-bar te maken die verschillende patronnen kan weergeven ( 1 rij LED's dus).
Tot nu toe heb ik gewoon uitgangen hoog/laag gemaakt zodat ik 8 LED's direct kan aansturen. De software hiervoor is erg simpel, het was gewoon als klein testje. De LED-bar gaat zo'n 28 LED's bevatten, maar het is te vroeg om daar mee te beginnen.
Daarom had ik al een soort van test opstellingkje gemaakt met 4 LED's.
Max. 10mA per LED dus 20mA per 2, wat dus kon omdat de max 25mA is.
(dit omdat ik nog geen transistoren had.)
Nu moet hiervoor de software geschreven worden, maar ik heb geen enkel idee waar te beginnen.
PortA lijnen moeten dus gaan 'scannen', waarbij PortB lijnen hoog moeten maken bij de LED's die aan moeten gaan.

Hoe moet ik dan aan gaan geven welke LEDs aan moeten? Bij directe aanstuuring is dat simpel:

b'10000000'
b'01000000'
b'00100000'
b'00010000'
etc.

Alleen hoe moet ik dit doen nu ik ook met kolommen rekening moet houden, en de timing ook belangrijk is?

Zou ik bijv. de data per kolom in een geheugenadres kunnen zetten? En dat de(/een) timer die data per kolom ophaalt?

Ik hoop dat ik hier wat duidelijker mee ben geweest.
Zou iemand mij op weg willen helpen?

Ik ben alweer een stukje verder gekomen, en heb wat code uitgedacht en afgekeken van andere stukken. Dit heb ik in elkaar gezet:


;********************************
; Multiplex TESTING 1
; 4x LED in matrix
;********************************

		porta EQU 05h
		portb EQU 06h
 		trisa EQU 85h
		trisb EQU 86h
		row0  EQU 41h 
		row1  EQU 42h
		SDelayCount	EQU H'0C'
		FrameDelay	EQU H'CD'
		

		BSF 	03,5   ;** PortA en B uitgangen. 
		CLRF	trisa
		CLRF	trisb 
	 	BCF 	03,5	

;---------------------------
; Main Loop

Main
	MOVLW b'11110111'
	MOVWF row0
	MOVLW b'11111111'
	MOVWF row1
	CALL	Display 
	

	MOVLW b'11101111'
	MOVWF row0
	MOVLW b'11111111'
	MOVWF row1
	CALL 	Display

	MOVLW b'11111111'
	MOVWF row0
	MOVLW b'11110111'
	MOVWF row1
	CALL 	Display

	MOVLW b'11111111'
	MOVWF row0
	MOVLW b'11101111'
	MOVWF row1
	CALL 	Display


GOTO  Main


;---------------------------
; Display Frame


Display		
		MOVLW 	h'CD'
		MOVWF	FrameDelay

DLoop
		MOVF 	row0, 0
		MOVWF	portb
		MOVLW	b'00000001'
		MOVWF	porta
		CALL  	Delay

		MOVF	row1, 0
		MOVWF 	portb
		MOVLW	b'00000010'
		MOVWF	porta
		CALL 	Delay
		DECFSZ	FrameDelay
		GOTO	DLoop
		RETURN

;---------------------------
;	delay for multiplexing

Delay	MOVLW	h'0C'	
		MOVWF	SDelayCount	
SDelayLoop
		NOP
		NOP
		NOP
		NOP
		DECFSZ	SDelayCount
		GOTO	SDelayLoop
		RETLW	0


END		

Alle LED's knipperen hiermee veelste snel (geen patroon zichtbaar), meer dan 10x per seconden. FrameDelay heb ik van 0x0D al naar 0xCD gewijzigt, maar zonder resultaat.
Kan iemand er eens naar kijken, en wat over uitleggen?

Wat is je kloksnelheid?

//EDIT
De snelheid van de klok bepaalt hoe snel het delay-register op 0 komt.

[Bericht gewijzigd door DIY op ]

Ik heb echt geen idee van wat de klok is. Het was de bedoeling dat ik er een 4mhz kristal tussen zou zetten, alleen had ik geen goede condensator. Toen er een RC klock van gemaakt (wat uiteindelijke meer R is geworden). Waar ik ook geen goede condensator voor had. Nu heb ik dus alleen een weerstand van 4k7 tussen VDD en Clock In.

Zou het slim zijn om eerst even een paar condensatoren te halen en een XT clock te maken? :)

Het princiepe van multiplexing is dat je een ic hebt dat een adres ingang heeft en een data ingang. Via de adreslijn kies je dan welke datalijn aan de uitgang van het ic komt.

Met een led matrix is het net hetzelfde, hier kies je een kolom en een rij ipv een adres en de data. Zo kun je een 2 dimensianale matrix aansturen door X lijnen waarbijX gelijk is aan het aantal kolommen+het aantal rijen.

een 5x6 matrix heeft 30 leds en kan met 5+6=11 lijnen gestuurd worden.

Door sneller dan je oog het kan waarnemen heel de matrix doorloopt lijkt het alsof de leds tegelijk branden.

Op 4 september 2004 17:38:01 schreef M-ThijZ:
Ik heb echt geen idee van wat de klok is. Het was de bedoeling dat ik er een 4mhz kristal tussen zou zetten, alleen had ik geen goede condensator. Toen er een RC klock van gemaakt (wat uiteindelijke meer R is geworden). Waar ik ook geen goede condensator voor had. Nu heb ik dus alleen een weerstand van 4k7 tussen VDD en Clock In.

Zou het slim zijn om eerst even een paar condensatoren te halen en een XT clock te maken? :)

Alleen een weerstand? kan dat? daar kan toch nooit een pulssignaal van komen?

Op 5 september 2004 21:18:38 schreef Arjan Swets:
Alleen een weerstand? kan dat? daar kan toch nooit een pulssignaal van komen?

Ik stond er zelf ook even van te kijken :)

staat die niet op interne clock... en zijn die aansluitingen op de pic gewoon in/uitgangen?

Alleen weerstand kan natuurlijk in theorie, capaciteit zit er natuurlijk altijd wel.
De bedoeling van multiplexen is juist dat alles snel , heel snel knippert.
Je zet led 1 even aan, dan weer uit, en led 3 even aan en uit, dan weer 1 aan en uit. Doe je het snel genoeg, lijkt 1 te branden, 2 uit, en 3 aan. Om te beginnen doe je het gewoon langzaam, zodat je ziet hoe het knippert ( 1 aan, weer uit, 3 aan, weer uit ) en dan voer je de snelheid op.
( PS uit de datasheet , Cosc minimaal > 20 pF, dat is erg weinig, dus capaciteit van sporen / pinnen kan genoeg zijn, niet aan te bevelen )

[Bericht gewijzigd door Sponcebert op ]

Op 6 september 2004 09:06:37 schreef Sponcebert:
De bedoeling van multiplexen is juist dat alles snel , heel snel knippert.
Je zet led 1 even aan, dan weer uit, en led 3 even aan en uit, dan weer 1 aan en uit. Doe je het snel genoeg, lijkt 1 te branden, 2 uit, en 3 aan. Om te beginnen doe je het gewoon langzaam, zodat je ziet hoe het knippert ( 1 aan, weer uit, 3 aan, weer uit ) en dan voer je de snelheid op.

Ik denk dat ik de theorie en de hardware kant wel begrijp, maar ik zou eigenlijk wel wat hulp kunnen gebruiken bij het schrijven van de software. De dingen die er moeten gebeuren, en waar ik op moet letten.

Ik begrijp niet helemaal wat je wilt. Volgens mij wil je de volgende 3 dingen :
a. Ledmatrix gebruiken in plaats van direct aansturen.
b. Hierop verschillende "afbeeldingen" maken.
c. Deze varieren.
Veronderstel dat je een looplicht wil met 8 ledjes:
Stap 1 : verzin een manier om 1 afbeelding weer te geven :
een byte X met bit voor een led.
Stap 2 : routine die je matrix aanstuurd.
( bit 1 hoog -> led 1 even aan )
( bit 2 laag -> led 2 niet even aan )
( bit 3 hoog -> led 3 eevn aan ).
heb je diteen halve seconde / 100 keer gedaan , maak je X je nieuwe waarde en gaat weer vrolijk 100 x bovenstaande doen.

Begin met een lange delay, kun je het goed zien.

Ok, ik zal eens kijken of ik dat zo in programmeertaal om kan zetten. Ik begin ASM een beetje te kennen, maar misschien is het beter om eerst met een hogere programmeertaal te beginnen.
Ik heb al wel wat ervaring met (visual-)Basic, dus ik zou daarin eens kunnen kijken. Met C heb ik geen ervaring (wel PHP wat er kwa structuur op lijkt).
Zijn daar ook wat freeware oplossingen voor waar een beginner wat mee kan?

btw. een paar posts terug had ik al een asm code gepost die ik in elkaar had gezet. Zit ik daarmee een beetje op de goede weg?