[HOWTO] LED kubus 5*5*5 met 74HC595

quote:

TrailBlazer schreef op maandag 19 maart 2007 @ 21:21:
in deze thread multiplexing frequentie/stroom werd er aangeraden door naftebakje ongeveer 8 keer de nominale stroom er doorheen te sturen. Je hebt dan dus maar 8/64 lichtopbrengst.

Hmmm, 8 keer de nominale stroom lukt nooit, en 8/64ste is veels te weinig naar mijn mening...
Ik denk dat ik maar een andere oplossing moet gaan zoeken, of genoegen nemen met deze lage lichtopbrengst.

Misschien probeer ik het anders wel met een 7x7 kubus, is sowieso goedkoper, en ook iets makkelijker...

quote:

Xqlusive schreef op maandag 19 maart 2007 @ 20:52:
Ik ben ook begonnen met het ontwerpen van mijn LED kubus. Ik heb nu een schema gemaakt voor een 8x8 kubus. Het enige probleem waar ik mee zit is dat ik het liefst zoveel mogelijk lichtopbrengst heb, en ik wil het minimum aantal aansluitingen gebruiken zodat het netjes lijkt.

Het minimum aantal aansluitingen bij een 8x8 cube is 72 (64 voor de X-coordinaten, 8 voor de Y coordinaten). Het probleem hierbij is dat er erg grote stromen geschakeld zullen moeten worden. Mijn idee is om per laag elk ledje apart te multiplexen, dus eerst X1Y1 dan X1Y2, X1Y3 enz, en dat dan voor alle 8 lagen tegelijk). Op deze manier staan er maar 8 ledjes tegelijk aan, en is de maximale stroom door de bc327 800mA (100mA per LED). Maar het nadeel is dat elk ledje maar 1/64 van de dutycycle aan staan.

Ik heb gekozen voor 15us als "aan" tijd voor een ledje, dit betekent dus dat de periodetijd 0.00096s bedraagt, dit is een frequentie van iets meer dan 1Khz(genoeg toch?).
Nu vraag ik me af wat er voor lichtopbrengst overblijft als ik het zo uitvoer, zelf denk ik dat een dutycycle van 1/64ste veels te kort is, maar met maar 72 aansluitdraden zie ik geen andere oplossing.
Zie ik iets over het hoofd, hebben jullie hier een oplossing voor ?

Hoeveel stroom mag ik eigenlijk door een ledje gooien als ik een dutycycle van 1/64ste neem, 64 keer de normale stroom lijkt me een beetje teveel van het goede... Als de stroom wel redelijk groot mag worden, kan ik altijd nog wat zwaardere transistors nemen (het zijn er toch maar 8 ).

je kunt gewoon het beste per laag schakelen dus max 64 ledjes tegelijk aan als je 100mA door je led stuurt komt er zo veel licht vanaf dat je het figuur niet duidelijk meer ziet (voor zo ver mijn ervaringen).

Ik ben druk mee bezig de 18Fxxx serie onder de knie te krijgen wat alleen niet echt wil lukken.

wat wil niet lukken: programmeren? aansluiten? kopen? of probeer je het ding echt onder je knie te schuiven ?

Ik ga het proberen met 8 andere PNP transistors (BC636), deze kunnen 1.5A leveren. Zodoende kan ik als ik 64 LEDs tegelijk aanstuur elke LED 20mA geven. Dit is dan bij een duty-cycle van 1/8.
Welke LED's hebben jullie genomen, er zijn zo veel verschillende....
Zelf dacht ik aan 5mm LEDs met een hoek groter dan 60 graden, en met een redelijke lichtopbrengst. Uiteraard moeten ze ook een stroom van 20mA kunnen trekken.
Waar hebben jullie ze gekocht, wat is een redelijke prijs per led ?

persoonlijk vind ik diffuse leds mooi voor een led kubus. Enne die duty-cycle berekeningen is wel erg leuk hoor maar een beetje overbodig. Als je echt de maximale lichtopbrengts wilt hebben dan is het wel slim om te gaan rekenen. Ik heb nu voor elk ledje een weerstand genomen zodat de led 20ma krijgt. En ik schakel per verdieping dus ik heb een duty-cycle van 1/8. Dat zou betekenen dat er maar 2.5ma door het ledje heen gaat. Geloof me in praktijk is dit veel meer. Ik ben nu bezig met de laatste draadjes van de schuifregisters naar de leds. Als dat klaar is zal ik eens gaan meten hoeveel stroom er nu echt loopt. Maar dat zal wel eind van de week worden ben ik bang

quote:

bazzzzzz schreef op dinsdag 20 maart 2007 @ 14:37:
persoonlijk vind ik diffuse leds mooi voor een led kubus. Enne die duty-cycle berekeningen is wel erg leuk hoor maar een beetje overbodig. Als je echt de maximale lichtopbrengts wilt hebben dan is het wel slim om te gaan rekenen. Ik heb nu voor elk ledje een weerstand genomen zodat de led 20ma krijgt. En ik schakel per verdieping dus ik heb een duty-cycle van 1/8. Dat zou betekenen dat er maar 2.5ma door het ledje heen gaat. Geloof me in praktijk is dit veel meer. Ik ben nu bezig met de laatste draadjes van de schuifregisters naar de leds. Als dat klaar is zal ik eens gaan meten hoeveel stroom er nu echt loopt. Maar dat zal wel eind van de week worden ben ik bang

Er loopt ook wel 20mA door het ledje, maar dit is dus maar voor 1/8 van de tijd. Hierdoor brand het ledje gewoon minder fel.
Misschien is 20mA voor 1/8ste duty-cycle ook wel genoeg, zoals al eerder werd genoemd moeten de LED's ook niet te fel zijn, anders is het hele effect weg.

Ik heb nu een complete simulatie van de 8x8 cube in Proteus gemaakt, ben nu bezig met het schrijven van een programma voor de PIC die de hele handel moet aansturen. Over een paar uur heb ik het denk ik wel werkend !

1 patroon is 64bytes groot, in de PIC passen er dus maar een paar, het lijkt me een leuk idee om EEPROM's te vullen met animaties. De informatie voor de ROM is gemakkelijk te genereren met een programmaatje. Zoals hier al eerder is genoemd door simpelweg checkboxjes te setten is een patroon te genereren, meerdere patronen achter elkaar en je hebt een animatie !

Jammergenoeg zal ik nog een paar maand moeten wachten met het echt opbouwen van de kubus, ik moet eerst mijn stage in Engeland nog afmaken....

quote:

bazzzzzz schreef op dinsdag 20 maart 2007 @ 14:37:
persoonlijk vind ik diffuse leds mooi voor een led kubus. Enne die duty-cycle berekeningen is wel erg leuk hoor maar een beetje overbodig. Als je echt de maximale lichtopbrengts wilt hebben dan is het wel slim om te gaan rekenen. Ik heb nu voor elk ledje een weerstand genomen zodat de led 20ma krijgt. En ik schakel per verdieping dus ik heb een duty-cycle van 1/8. Dat zou betekenen dat er maar 2.5ma door het ledje heen gaat. Geloof me in praktijk is dit veel meer. Ik ben nu bezig met de laatste draadjes van de schuifregisters naar de leds. Als dat klaar is zal ik eens gaan meten hoeveel stroom er nu echt loopt. Maar dat zal wel eind van de week worden ben ik bang

dat kan toch gewoon niet. Je kan echt niet de wetten van Ohm veranderen. Als je er 1/8 van de tijd 20 mA doorheen stuurt zal je gemiddeld dus inderdaad maar 2,5 mA er doorheen sturen

ik heb er ook eens over na lopen denken en kben er ook nog niet uit. Waar wel ff rekening mee gehouden moet worden is dat 2,5ma gemiddeld die ik dan bereik feller is dan het ledje gewoon op maar 2,5 ma.

Naja eind van de week zal ik alles eens doormeten en kijken hoeveel er nu werkelijk doorheenstroomt:P

het enige wat ik kan bedenken is dat het rendement op een hogere stroom hoger is dan op een lagere stroom. Dit zou dan inderdaad betekenen dat je meer licht lijkt te krijgen dan met 2,5 mA constant

Ik heb mijn kubus nu ook gedeeltelijk werkend morgen ff de laaste 8 draden aansluit en dan volop programmeren, kan de ledjes al laten branden.

Moet nu nog ff testen met alle ledjes aan en dan laag voor laag zodat ik een stroom heb van 20mA nu heb ik maar 112mA door 32 ledjes.

ik hoef alleen nog maar even mijn verdieping print aan te sluiten. En daarop nog een paar draadjes solderen. Dan kan ik gaan testen:P dus mischien lukt het mij vandaag nog wel om het af te krijgen:P

Het schema voor mijn 8x8 cube is klaar ! Momenteel kan ik alleen patronen in de PIC programmeren, later wil ik via rs232 of met geheugenmodule via spi/i2c animaties doorsturen. Ik heb het programma zo opgebouwd dat telkens 8 bitjes tegelijk worden ingeklokt op alle shiftregisters.

Een compleet patroon kost 64 Bytes, in de eerste Byte staat de data over LED1 van alle 8 verdiepingen, in de 2e byte staat de data over LED2 van alle 8 verdiepingen enz...

Plaatje op imageshack (popups!)
Dit is het schema wat ik gemaakt heb (een deel er van, maar 1 shiftregister),er zijn veel onderdelen uit jullie ontwerpen in verwerkt, bedankt daarvoor !
De bc327's worden in het echt trouwens zwaardere transistors, de bc636 wil ik gaan gebruiken hiervoor, deze kunnen 1,5A leveren, dus ongeveer 20mA per LED.

Is dit ontwerp zo goed, of heb ik ergens domme fouten gemaakt ? Normaal zou ik het wel kunnen simuleren, maar blijkbaar is het erg moeilijk om een LED matrix te simuleren, proteus geeft elke keer de melding dat de timestep te klein in
Als ik het schema simuleer met een matrix van 3x3 werkt het wel iig

Is er iemand die de ASM code wil zien ?
Ik dacht ik vraag het eerst maar voordat ik hier 600 regels code heen klap

Edit: Hier nog een linkje naar het volledige schema, daar heb je misschien wat meer aan.
Plaatje op imageshack (popups!)

Xqlusive wijzigde dit bericht 21-03-2007 16:22 (15%)

van mij mag je je asm code hier wel neergooien. En als het echt 600 regels zijn dan ben ik vrijwillig voor een mailtje:P kijken of ik er nog iets van kan leren. Dit is bij mij de code voor mijn 5*5*5 kubus. Hierin heb ik dan echt elk ledje behandeld:
code:

call    v1
            ; 87654321    nummer van de led
    movlw    b'10101010'    ; zet waarde in w
    call    inklokken1
    movlw    b'10101010'
    call    inklokken1
    movlw    b'10101010'
    call    inklokken1
    bcf        ledx
    call    delay

    call    v2
    movlw    b'01010101'
    call    inklokken1
    movlw    b'01010101'
    call    inklokken1
    movlw    b'01010101'
    call    inklokken1
    bsf        ledx
    call    delay

    call    v3
    movlw    b'10101010'
    call    inklokken1
    movlw    b'10101010'
    call    inklokken1
    movlw    b'10101010'
    call    inklokken1
    bcf        ledx
    call    delay

    call    v4
    movlw    b'01010101'
    call    inklokken1
    movlw    b'01010101'
    call    inklokken1
    movlw    b'01010101'
    call    inklokken1
    bsf        ledx
    call    delay

    call    v5
    movlw    b'10101010'
    call    inklokken1
    movlw    b'10101010'
    call    inklokken1
    movlw    b'10101010'
    call    inklokken1
    bcf        ledx
    call    delay

call v1 verwijst naar subroutine v1 waarin ik verdieping 1 aanzet

trouwens vraagje over jou schema: waarom gebruik jij de 4096(?) en de 74hc595. Gebruik toch gewoon overal dezelfde is veel en veel makkelijker!

edit 2: waarom trouwens zwaardere transistors? Je hebt maar 8 zware transistors nodig(of gebruik gewoon FET's) dit zijn de transistors voor de horizontale vlakken(=verdiepingen). Door de andere loopt maar 20ma. Of meer als je je leds feller wilt hebben

bazzzzzz wijzigde dit bericht 21-03-2007 21:23 (15%)

Ik heb mijn kubus hardware matig klaar (op EEPROM en SD/MMC na) alleen 1 led driver is half stuk 1 uitgang blijft continue aan.

quote:

bazzzzzz schreef op woensdag 21 maart 2007 @ 21:18:

trouwens vraagje over jou schema: waarom gebruik jij de 4096(?) en de 74hc595. Gebruik toch gewoon overal dezelfde is veel en veel makkelijker!

edit 2: waarom trouwens zwaardere transistors? Je hebt maar 8 zware transistors nodig(of gebruik gewoon FET's) dit zijn de transistors voor de horizontale vlakken(=verdiepingen). Door de andere loopt maar 20ma. Of meer als je je leds feller wilt hebben

Ik gebruik de 4028 omdat dit veel makkelijker werkt als er maximaal 1 laag aan hoeft te staan. Ik hoef nu maar 1 bitje (gray code) om te zetten en de volgende laag wordt geselecteerd. Als ik de 74hc595 gebruik moet ik het hele shiftregister opnieuw vullen. Aangezien ik de laag schakel voor de shiftregisters geupdate zijn zal de waarde voor laag 1, heel even op laag 2 te zien zijn. Doordat dit maar 1 instructie te zien is, is het te verwaarlozen, als ik een compleet shiftregister moest schrijven zou het veel langer duren.

Met die zwaardere transistors bedoel ik dan ook alleen de PNP's (bc327). Deze zullen energie (had laatst een discussie over stoom, en dit is de uitkomst) moeten leveren voor maximaal 64 LED's, de bc547's hoeven idd maar 20mA per stuk aan te kunnen.

De onderstaande code staat in MPLAB netjes onder elkaar, maar op 1 of andere vage manier is dit in notepad niet zo. De layout is daardoor een beetje veranderd. Zoals je zal zien zit er erg veel copy/paste werk in, een loop zou hier misschien mooier zijn, maar dit wou niet helemaal lukken omdat er ook elke keer een andere register gelezen moet worden.

In de Get_pattern routine word nu nog een vast patroon in het geheugen geladen, later wil ik dat hier een patroon uit een EEPROM word geladen zodat ik animaties kan maken.
code:

title "PIC16F876 LED cube"
            list p=16f876
            #include    <p16f876.inc>
        
ROW1_BIT1        equ        0x20        ;alle 1ste LED's van alle lagen van de eerste rij
ROW1_BIT2        equ        0x21        ;alle 2de LED's van alle lagen van de eerste rij
ROW1_BIT3        equ        0x22        ;alle 3de LED's van alle lagen van de eerste rij
ROW1_BIT4        equ        0x23        ;enz...
ROW1_BIT5        equ        0x24        ;enz...
ROW1_BIT6        equ        0x25
ROW1_BIT7        equ        0x26
ROW1_BIT8        equ        0x27

ROW2_BIT1        equ        0x28
ROW2_BIT2        equ        0x29
ROW2_BIT3        equ        0x2A
ROW2_BIT4        equ        0x2B
ROW2_BIT5        equ        0x2C
ROW2_BIT6        equ        0x2D
ROW2_BIT7        equ        0x2E
ROW2_BIT8        equ        0x2F

ROW3_BIT1        equ        0x30
ROW3_BIT2        equ        0x31
ROW3_BIT3        equ        0x32
ROW3_BIT4        equ        0x33
ROW3_BIT5        equ        0x34
ROW3_BIT6        equ        0x35
ROW3_BIT7        equ        0x36
ROW3_BIT8        equ        0x37

ROW4_BIT1        equ        0x38
ROW4_BIT2        equ        0x39
ROW4_BIT3        equ        0x3A
ROW4_BIT4        equ        0x3B
ROW4_BIT5        equ        0x3C
ROW4_BIT6        equ        0x3D
ROW4_BIT7        equ        0x3E
ROW4_BIT8        equ        0x3F

ROW5_BIT1        equ        0x40
ROW5_BIT2        equ        0x41
ROW5_BIT3        equ        0x42
ROW5_BIT4        equ        0x43
ROW5_BIT5        equ        0x44
ROW5_BIT6        equ        0x45
ROW5_BIT7        equ        0x46
ROW5_BIT8        equ        0x47

ROW6_BIT1        equ        0x48
ROW6_BIT2        equ        0x49
ROW6_BIT3        equ        0x4A
ROW6_BIT4        equ        0x4B
ROW6_BIT5        equ        0x4C
ROW6_BIT6        equ        0x4D
ROW6_BIT7        equ        0x4E
ROW6_BIT8        equ        0x4F

ROW7_BIT1        equ        0x50
ROW7_BIT2        equ        0x51
ROW7_BIT3        equ        0x52
ROW7_BIT4        equ        0x53
ROW7_BIT5        equ        0x54
ROW7_BIT6        equ        0x55
ROW7_BIT7        equ        0x56
ROW7_BIT8        equ        0x57

ROW8_BIT1        equ        0x58
ROW8_BIT2        equ        0x59
ROW8_BIT3        equ        0x5A
ROW8_BIT4        equ        0x5B
ROW8_BIT5        equ        0x5C
ROW8_BIT6        equ        0x5D
ROW8_BIT7        equ        0x5E
ROW8_BIT8        equ        0x5F
delay            equ        0x60


        
        
        org        0x00
        goto    INIT

INIT
        bcf        STATUS,RP1
        bsf        STATUS,RP0            ;select bank 1
        movlw    0x00
        movwf    TRISB
        movwf    TRISA                ;set PORTB and PORTA as output
        movlw    0x07
        movwf    ADCON1                ;set PORTA as digital IO
        bcf        STATUS,RP0            ;select bank 0
        clrw
        movwf    PORTA                ;set al outputs to 0
        goto     Main

Main
        call    GET_PATTERN            ;get the next pattern from the memory
        call    SET_SHIFTREG1        ;show row 1
        call    Delay_routine
        call    SET_SHIFTREG2        ;show row 2
        call    Delay_routine
        call    SET_SHIFTREG3        ;show row 3
        call    Delay_routine
        call    SET_SHIFTREG4        ;show row 4
        call    Delay_routine        
        call    SET_SHIFTREG5        ;show row 5
        call    Delay_routine
        call    SET_SHIFTREG6        ;show row 6
        call    Delay_routine
        call    SET_SHIFTREG7        ;show row 7
        call    Delay_routine
        call    SET_SHIFTREG8        ;show row 8
        goto     Main



SET_SHIFTREG1

        movf    ROW1_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW1_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW1_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW1_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW1_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW1_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW1_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW1_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        bcf        PORTA,3                ;set row selector (000)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        
        return


SET_SHIFTREG2

        movf    ROW2_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW2_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW2_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW2_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW2_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW2_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW2_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW2_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        bsf        PORTA,5                ;set row selector (001)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        return

SET_SHIFTREG3

        movf    ROW3_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW3_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW3_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW3_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW3_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW3_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW3_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW3_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        bsf        PORTA,0                ;set row selector (011)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        
        return

SET_SHIFTREG4

        movf    ROW4_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW4_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW4_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW4_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW4_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW4_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW4_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW4_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        bcf        PORTA,5                ;set row selector (010)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        
        return

SET_SHIFTREG5

        movf    ROW5_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW5_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW5_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW5_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW5_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW5_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW5_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW5_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        bsf        PORTA,3                ;set row selector (110)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        
        return

SET_SHIFTREG6

        movf    ROW6_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW6_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW6_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW6_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW6_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW6_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW6_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW6_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        bsf        PORTA,5                ;set row selector (111)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        
        return

SET_SHIFTREG7

        movf    ROW7_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW7_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW7_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW7_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW7_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW7_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW7_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW7_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        
        bcf        PORTA,0                ;set row selector (101)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        
        return

SET_SHIFTREG8

        movf    ROW8_BIT1,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data1 to shiftregister        
        movf    ROW8_BIT2,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data2 to shiftregister
        movf    ROW8_BIT3,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data3 to shiftregister        
        movf    ROW8_BIT4,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data4 to shiftregister
        movf    ROW8_BIT5,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data5 to shiftregister        
        movf    ROW8_BIT6,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data6 to shiftregister
        movf    ROW8_BIT7,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data7 to shiftregister
        movf    ROW8_BIT8,0
        movwf    PORTB
        bsf        PORTA,2                
        nop
        bcf        PORTA,2                ;set data8 to shiftregister
    
        bcf        PORTA,5                ;set row selector (100)
        
        bsf        PORTA,1
        nop
        bcf        PORTA,1                ;set data on storage register (LED's ON)
        
        return



GET_PATTERN                    
        movlw    0xFF                ;in this routine the pattern will be
        movwf    ROW1_BIT1            ;downloaded from either the PC (rs232) or from EEPROM
        movwf    ROW1_BIT2            ;for testing purposes a simple pattern has been programmed
        movwf    ROW1_BIT3            
        movwf    ROW1_BIT4
        movwf    ROW1_BIT5
        movwf    ROW1_BIT6
        movwf    ROW1_BIT7
        movwf    ROW1_BIT8
        movlw    0x00
        movwf    ROW2_BIT1
        movwf    ROW2_BIT2
        movwf    ROW2_BIT3
        movwf    ROW2_BIT4
        movwf    ROW2_BIT5
        movwf    ROW2_BIT6
        movwf    ROW2_BIT7
        movwf    ROW2_BIT8
        movlw    0xFF
        movwf    ROW3_BIT1
        movwf    ROW3_BIT2
        movwf    ROW3_BIT3
        movwf    ROW3_BIT4
        movwf    ROW3_BIT5
        movwf    ROW3_BIT6
        movwf    ROW3_BIT7
        movwf    ROW3_BIT8
        movlw    0x00
        movwf    ROW4_BIT1
        movwf    ROW4_BIT2
        movwf    ROW4_BIT3
        movwf    ROW4_BIT4
        movwf    ROW4_BIT5
        movwf    ROW4_BIT6
        movwf    ROW4_BIT7
        movwf    ROW4_BIT8
        movlw    0xFF
        movwf    ROW5_BIT1
        movwf    ROW5_BIT2
        movwf    ROW5_BIT3
        movwf    ROW5_BIT4
        movwf    ROW5_BIT5
        movwf    ROW5_BIT6
        movwf    ROW5_BIT7
        movwf    ROW5_BIT8
        movlw    0x00
        movwf    ROW6_BIT1
        movwf    ROW6_BIT2
        movwf    ROW6_BIT3
        movwf    ROW6_BIT4
        movwf    ROW6_BIT5
        movwf    ROW6_BIT6
        movwf    ROW6_BIT7
        movwf    ROW6_BIT8
        movlw    0xFF
        movwf    ROW7_BIT1
        movwf    ROW7_BIT2
        movwf    ROW7_BIT3
        movwf    ROW7_BIT4
        movwf    ROW7_BIT5
        movwf    ROW7_BIT6
        movwf    ROW7_BIT7
        movwf    ROW7_BIT8
        movlw    0x00
        movwf    ROW8_BIT1
        movwf    ROW8_BIT2
        movwf    ROW8_BIT3
        movwf    ROW8_BIT4
        movwf    ROW8_BIT5
        movwf    ROW8_BIT6
        movwf    ROW8_BIT7
        movwf    ROW8_BIT8

        return    

Delay_routine
        movlw    0x15            ;65 instructies vertragen
        movwf    delay
again    
        decfsz delay,1
        goto again
        return
        
        end

Woei, ik heb nieuwe boortjes, dus ben nieuwe gaatjes aan het maken, nog even dan is die voet ook af
Dan kan ik 'm aansluiten en de code gaan testen.

hmmmm jou code is niet erg handig. jij gooit de data erin als bits. ik gooi er telkens een byte in. en dan met het rlf commando verplaats ik die bits naar links. De "uitgeschoven" bit die staat dan in het C register. Dan is veel overzichtelijker programmeren. Of mijn manier veel korter is betwijfel ik

dit is denk ik wel heel snel maar zeker niet het efficients in aantal regel codes is kwestie van afwegen

quote:

bazzzzzz schreef op donderdag 22 maart 2007 @ 20:24:
hmmmm jou code is niet erg handig. jij gooit de data erin als bits. ik gooi er telkens een byte in. en dan met het rlf commando verplaats ik die bits naar links. De "uitgeschoven" bit die staat dan in het C register. Dan is veel overzichtelijker programmeren. Of mijn manier veel korter is betwijfel ik

Dat het niet echt efficient is qua code klopt, het programma is dan ook in een paar uur in elkaar geflanst. Echter verschillen onze routine's niet zo heel erg veel, die van mij lijkt veel langer omdat ik ten eerste 64 bytes moet versturen ipv 25, en ik heb alles in 1 routine staan, terwijl jij gebruik van van call instructies.
Ik ga nog proberen er een mooie loop van te maken, moet toch wel kunnen dacht ik, maar weten jullie misschien een mooie manier om elke iteratie een ander register te schrijven naar PORTB ?

Edit: Ik gooi er trouwens ook elke keer een byte in, ik stuur 8 bits tegelijk naar buiten naar 8 verschillende shift registers

Xqlusive wijzigde dit bericht 22-03-2007 21:09 (34%)

In dit topic staat een stukje code die ik ooit heb bedacht voor een AVR en een 74HC595
[AVR/ASM] hoe bitjes serieel uitklokken

quote:

TrailBlazer schreef op donderdag 22 maart 2007 @ 21:37:
In dit topic staat een stukje code die ik ooit heb bedacht voor een AVR en een 74HC595
[AVR/ASM] hoe bitjes serieel uitklokken

Het probleem is niet echt het serieel uitsturen, maar meer hoe ik in 1 loop die 64 keer uitgevoerd word elke iteratie een ander register benader. Ik heb namelijk 64 bytes in het geheugen staan, die 1 voor 1 naar de shift registers gestuurd moeten worden. Op de huidige manier roep ik eigenlijk 8 verschillende routines aan, die dan weer 8 verschillende bytes uitsturen. maar dit moet toch op een betere manier kunnen ? Net zoals je normaal in hogere talen met arrays werkt, elke iteratie gewoon het argument veranderen: data[i], bij elke iteratie i verhogen zodat het volgende register word gelezen.

quote:

Xqlusive schreef op vrijdag 23 maart 2007 @ 10:03:
[...]


Het probleem is niet echt het serieel uitsturen, maar meer hoe ik in 1 loop die 64 keer uitgevoerd word elke iteratie een ander register benader. Ik heb namelijk 64 bytes in het geheugen staan, die 1 voor 1 naar de shift registers gestuurd moeten worden. Op de huidige manier roep ik eigenlijk 8 verschillende routines aan, die dan weer 8 verschillende bytes uitsturen. maar dit moet toch op een betere manier kunnen ? Net zoals je normaal in hogere talen met arrays werkt, elke iteratie gewoon het argument veranderen: data[i], bij elke iteratie i verhogen zodat het volgende register word gelezen.

Je hebt volgens mij wel de mogelijkheid om met pointers te werken deze wijzen dan naar een geheugen adres. Als je deze point dan telkens ophoogt loop ze zo 8 geheugen adressen door

quote:

TrailBlazer schreef op vrijdag 23 maart 2007 @ 10:12:
[...]

Je hebt volgens mij wel de mogelijkheid om met pointers te werken deze wijzen dan naar een geheugen adres. Als je deze point dan telkens ophoogt loop ze zo 8 geheugen adressen door

het nieuwe programma gebruik makend van pointers !
Bedankt voor de tip, het programma is denk ik haast een factor 10 kleiner geworden !
Overigens haal ik nu telkens 8 bytes op in plaats van 64 tegelijk.

het COMPLETE programma:
code:

title "PIC16F876 LED cube"
                list p=16f876
                #include    <p16f876.inc>

delay    equ        0x28
layer    equ        0x29

        org        0x00
        goto     init

init
        bcf        STATUS,RP1
        bsf        STATUS,RP0            ;select bank 1
        clrf    TRISB
        clrf    TRISA                ;set PORTB and PORTA as output
        movlw    0x07
        movwf    ADCON1                ;set PORTA as digital IO
        bcf        STATUS,RP0            ;select bank 0
        clrf    PORTA                ;set al outputs to 0
        clrf    PORTB
        goto     main

main
        clrf    layer
LOOP    call    get_next_layer        ;data voor de volgende laag ophalen
        call    set_shiftregister    ;zet de data op de shiftregisters
        movf    layer,0
        movwf    PORTA
        bsf        PORTA,5
        nop
        bcf        PORTA,5                ;storage klokpuls
        call     delay_routine
        incf    layer,1
        btfss    layer,3
        goto    LOOP
        goto     main
        
get_next_layer                ;deze routine laad 8 bytes
        movlw    0x20        ;in de registers 0x20 tot 0x27
        movwf    FSR            ;later komt hier een routine 
        movlw    0xFF        ;om patronen uit een EEPROM te lezen
NEXT    movwf    INDF
        incf    FSR,1
        btfss    FSR,3
        goto    NEXT
        return

set_shiftregister            ;in deze routine zulen alle 8
        movlw    0x20        ;shiftregister gevuld worden    
        movwf    FSR            ;met de nieuwe data
AGAIN    movf    INDF,0
        movwf    PORTB        ;zet de data op PORTB
        bsf        PORTA,3
        nop
        bcf        PORTA,3        ;shift klokpuls
        incf    FSR,1
        btfss    FSR,3        ;8 bytes verstuurd ?
        goto    AGAIN
        return

delay_routine
        movlw    0x15
        movwf    delay
REPEAT    decfsz    delay,1
        goto    REPEAT
        return
    
        end

Hoe doen jullie figuren maken die bijvoorbeeld kunnen draaien, dus hoe maak je z'n figuur met gewoon 1 voor 1 de de leds in een variable zetten of anders ?

Ik doe nu dus kijken wat ik voor figuur wil en dan zet ik die in een variable maar als ik hem dan wil laten draaien of ergens anders neer wil zetten moet ik die code weer veranderen.

het makkelijkst is: Rekening houden met wat led1, 2, 3 enzovoort is. Bij mij lopen de leds een rondje. De buitenste ring is dus led1tm 23. Als ik iets wil roteren dan zorg ik dat dat figuur in 1 schuifregister staat.

Dus dan heb je van elke verdieping 8 bits. bijvoorbeeld b'00101000'. Dan vul ik de andere schuifregisters met nullen zodat die leds uit zijn.

Dan met het commando rlf(rotate left through carry) verschuif ik het geheel dus 8 keer. En tadaa je plaatje is verschoven. Waar je wel aan moet denken is dat je een routine maakt die dus elke keer het uitgeschoven bitje leest en dat bitje weer in het volgende schuifregister gooit.