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

[Xqlusive]

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...

[Cyrus The Virus]

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.

[MeMoRy]

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

[Xqlusive]

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 ?

[bazzzzzz]

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

[Xqlusive]

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....

[TrailBlazer]

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

[bazzzzzz]

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

[TrailBlazer]

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

[Cyrus The Virus]

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.

[bazzzzzz]

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

[Xqlusive]

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...


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.

[Voor 15% gewijzigd door Xqlusive op 21-03-2007 16:22]

[bazzzzzz]

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

[Voor 15% gewijzigd door bazzzzzz op 21-03-2007 21:23]

[Cyrus The Virus]

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.

[Xqlusive]

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

[SA007]

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.

[bazzzzzz]

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

[TrailBlazer]

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

[Xqlusive]

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

[Voor 34% gewijzigd door Xqlusive op 22-03-2007 21:09]

[TrailBlazer]

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

[Xqlusive]

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.

[TrailBlazer]

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

[Xqlusive]

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

[Cyrus The Virus]

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.

[bazzzzzz]

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.

[Xqlusive]

Mijn plan is om gewoon voor elk verschillend patroon een code te genereren, dus per patroon is dat dan 64 bytes. Als ik een animatie wil, dan zal ik dus meerdere patronen achter elkaar moeten afspelen. Dus voor een animatie van 30 frames ben ik 30*64=1920 bytes kwijt. Dit kost wel veel ruimte, maar als ik dit via rs232 doe, of via een EEPROM is dit wel veel makkelijker. Je kan dan gewoon met een simpel programma vinkjes zetten welke LED's je aan wil, en dan automatisch een code laten genereren.

[Cyrus The Virus]

Xqlusive schreef op zaterdag 24 maart 2007 @ 17:41:
Mijn plan is om gewoon voor elk verschillend patroon een code te genereren, dus per patroon is dat dan 64 bytes. Als ik een animatie wil, dan zal ik dus meerdere patronen achter elkaar moeten afspelen. Dus voor een animatie van 30 frames ben ik 30*64=1920 bytes kwijt. Dit kost wel veel ruimte, maar als ik dit via rs232 doe, of via een EEPROM is dit wel veel makkelijker. Je kan dan gewoon met een simpel programma vinkjes zetten welke LED's je aan wil, en dan automatisch een code laten genereren.

Ja dat wil ik dus ook via USB of SD/MMC, ik heb alle hardware alleen de software is een ander verhaal.

Wil ook nog een keer een VU meter maken via de A/D converter of iets met met een losse 8 kanaals VU meter en dan via SPI.

Heb nu ook de eeprom werkend, nu alleen nog SD/MMC (maar dat zal wel lukken denk ik, behalve als ik FAT ga gebruiken). USB zal denk ik een onmogelijk taak worden of het duurd eeuwig

[Voor 24% gewijzigd door Cyrus The Virus op 26-03-2007 09:56]

[_ferry_]

Ik heb de leds binnen, en zat dus weer even in dit topic te lezen, en nu keek ik in de hc595 datasheet, en daarin staat dat hij 35mA per pin kan leveren. Dus in feite heb je helemaal geen transitors nodig? En eigenlijk ook geen weerstand omdat de stroom niet boven de 20mA zal uitkomen als je multiplext.
Dan laat ik de schuifregisters gewoon de anodes aansturen, en met N-channel fet's kan ik vervolgens de lagen weer multiplexen. Scheelt een hoop soldeerwerk

[Cyrus The Virus]

_ferry_ schreef op zaterdag 31 maart 2007 @ 09:25:
Ik heb de leds binnen, en zat dus weer even in dit topic te lezen, en nu keek ik in de hc595 datasheet, en daarin staat dat hij 35mA per pin kan leveren. Dus in feite heb je helemaal geen transitors nodig? En eigenlijk ook geen weerstand omdat de stroom niet boven de 20mA zal uitkomen als je multiplext.
Dan laat ik de schuifregisters gewoon de anodes aansturen, en met N-channel fet's kan ik vervolgens de lagen weer multiplexen. Scheelt een hoop soldeerwerk

Hier heb ik een werkend schema misschien heb je er wat aan

http://users.telenet.be/C...203D-Ledcube%20Schema.jpg
http://users.telenet.be/C...ct%203D-Ledcube%20PCB.jpg

[Voor 13% gewijzigd door Cyrus The Virus op 31-03-2007 11:54]

[_ferry_]

Niet heel veel
Je maakt geloof ik gebruik van andere IC's.

Ik heb nu 8x hc595 voor de led's. Gewoon elke rij 1, de kolommen doe ik denk ik direct via N-channel FET's op de PIC, misschien later ook nog via een 595, maar ik denk dat ik de uitgangen van de pic toch verder niet nodig heb.

Zit nu alleen nog met welke uitgangen ik wel en niet moet aansluiten op de pic, ik ben nu gewoon draadjes aan het trekken naar pin 11,12,13, en 14met 9. Kan dan later wel testen welke wel/niet van belang zijn, omdat de output enable misschien nog wel eens handig kan zijn bijv.

Doe achter de schuifregisters gewoon weerstanden van 82ohm ofzo, kijk wel ff wat ik heb liggen

[Cyrus The Virus]

_ferry_ schreef op zaterdag 31 maart 2007 @ 15:06:
Niet heel veel
Je maakt geloof ik gebruik van andere IC's.

Ik heb nu 8x hc595 voor de led's. Gewoon elke rij 1, de kolommen doe ik denk ik direct via N-channel FET's op de PIC, misschien later ook nog via een 595, maar ik denk dat ik de uitgangen van de pic toch verder niet nodig heb.

Zit nu alleen nog met welke uitgangen ik wel en niet moet aansluiten op de pic, ik ben nu gewoon draadjes aan het trekken naar pin 11,12,13, en 14met 9. Kan dan later wel testen welke wel/niet van belang zijn, omdat de output enable misschien nog wel eens handig kan zijn bijv.

Doe achter de schuifregisters gewoon weerstanden van 82ohm ofzo, kijk wel ff wat ik heb liggen

Je hebt 4 stuur lijnen nodig voor de 595, en wat jij wil met die n-channel kan gewoon als je ze toch niet gebruikt.

Maar je moet wel transistoren gebruiken voor de 595 want de 595 kan niet sinken alleen sourcen en dat moet je niet hebben want je schakeld naar de ground toe als je de leds aan wil hebben.

de ic's die ik gebruik doen dat wel die kunnen sinken en hebben een constant current driver in gebouwt en op 1 IC kun je 16 led rijen hangen, en ze kunnen ook 120mA sinken.

[_ferry_]

Heb de meuk nu werkend na wat stomme foutjes (verwarrend, Ra3=pin2 )werkt het op 2D, voor 3D heb ik geen tijd, moet dan eerst nog 7x8x8 led's solderen Geen torren, alleen 8x hc595, pic en 8x FET. Lekker leeg printje dus Te sinken hoef ik niet, want de 595 stuurt 8 led's aan, en de fet's sinken dat vervolgens.

Maar 1 ding is wel gek, ik heb op Rb0-7 FET's zitten voor de kolommen, maar op de 1 of andere manier staat alles 1 regel verschoven, en komt de onderste dus bovenaan te staan. Erg maf, nu kan ik wel alle kolommen qua aansluiting 1 doorschuiven, maar dat is denk ik niet de oorzaak.

code:

        movlw   b'10000000'         ;selecteer verdieping, 1 tegelijk.
        movwf   PORTB
        movlw   b'00011000'             ; selecteer led's die aan moeten
        call    schuifregister1
        call    latch

Dat 8x achter elkaar geeft dan 1 afbeelding. Maar de regel die ik hier dus stuur, komt op de 2e terecht Heb ik dus een hele cooler pacman gemaakt, is ie doorgesneden

edit: misschien heeft dat wel iets te maken met het nagloei effect, want als ik iets op regel 3 zet, dan verschijnt het dus op regel 4, maar het is ook zwak zichtbaar op regel 3. Morgen weer een dag, zal dan eens kijken of ik wat aan de timings kan zien op de scoop en/of kan veranderen

edit2:

foto's




Ik weet IIG wel dat ik de cube van donker plexi maak: Uit zie je dan zowat niets, tenzij je heel fel licht uit de omgeving hebt. En zodra je hem dan aan zet zie je alleen wat je moet zien: lichtpuntjes. De draden zijn dan iets minder zichtbaar

edit 3: Na een nachtje slapen weet ik ook hoe die ghosting komt. Hij gooit de data de led's op, maakt vervolgens de volgende laag hoog, maar heeft dan nog niet de nieuwe data ingelezen. Dat duurt even, dus krijgt de laag nog vrolijk de data van de vorige laag. Ik ga daar van de week nog wel even mee klooien, eerst de data inlezen, en daarna de laag pas hoog maken.

[Voor 42% gewijzigd door _ferry_ op 01-04-2007 12:03]

[bazzzzzz]

@ferry. Vind je dat niet zonde van je ruimte maar 8 schuifregisters op één eurokaart? Ik heb 12 schuifregisters en 98 torren op 1 kaart:D kzal wel ff wat foto's maken binnenkort. De aansturing van de kubus is al klaar ik moet alleen nog gaan programmeren maar daar heb ik nog niet veel zin in:P

[_ferry_]

Ach, die 1€ voor een kaartje maakt ook niet zoveel uit, en mocht hetgeen wat ik nu doe niet helemaal werken, dan kan ik er nog altijd de ULN's achter zetten

Heb nu 4 kolommen in elkaar gesoldeerd, nu even wat kabels aanleggen en dan kan ik ze testen

[JKP-Kipmans]

* JKP-Kipmans is ook maar eens begonnen met het in elkaar zetten van een 5*5*5 LEDkubusje.

Alleen jammer dat ik een kleine misrekening heb gemaakt bij het bepalen van de afstand tussen de LEDs waardoor het geen kubus maar een soort 3D-rechthoek is geworden. Nou ja, eerst de aansturing maar eens afmaken en kijken of dat erg is.

[bazzzzzz]

voor je aansturing is het natuurlijk niet erg:P als hij een klein beetje afwijkt van een kubus zullen de meeste mensen het niet eens zien. Is het een centimeter dan is het storend. Is het nog meer dan denkt iedereen dat het de bedoeling was en je gewoon een balk wouw:)

[_ferry_]

Wpeo, nog 3 matrixen aansluiten, een schuifregister extra plaatsen voor de niveau's, en dan e behuizing+programmeren Kost aardig wat ruimte merkte ik al. Maargoed, ik heb een pic16f648, die's 2x zo groot als de 16f628. Maar ik heb nog niet echt een besef hoeveel plaatjes ik er dan in kwijt kan. heb nu 2 frames en da's 1,3kB volgens windows.

[TKoster]

Wooow, dat ziet er goed uit. Ik blijf het alleen jammer vinden dat het niet RS232 is.
En hoe heb je trouwens die kubus zo recht gekregen?

[_ferry_]

Thanks, ik heb telkens stroken van 8 led's gesoldeerd. die stak ik in een malletje van 8gaten naast elkaar op 2,2cm afstand. Pootjes van de led boog ik om, de ene meteen onder de led, de andere met een tangetjes, om hem zo later tegen de andere led aan te kunnen solderen. Die afstand was altijd hetzelfde, namelijk de breedte van mijn punt tangetje.
Daarna de hele vlakken overeind zetten, op het ijzerdraad wat horizontaal komt even kleine markeringen geven om de 2,2cm, en dan vast solderen

rs232/eeprom/CF komt hopelijk nog, maar dan moet ik mij daar eerst eens in verdiepen. Ik zou nu nog niet weten hoe ik data serieel kan uitlezen enzo

[_ferry_]

Inmiddels ingebouwd:


en werkend:
http://www.youtube.com/watch?v=J_ka5ztHOTM

Code zit in een 16f628, alleen ik heb geen idee hoeveel er nog bij kan.
Als ik hem aan het programmeren ben, telt hij tot de 0360¹⁶ als ik het goed onthouden heb.

Als hij vol is heb ik IIG nog een 16f648, daar past 2x zoveel in Ik stuur nu 2-4 lagen per frame aan.dat scheelt natuurlijk flink in ruimte dan wanneer je alle 8 de lagen moet aansturen voor een plaatje.

[Voor 3% gewijzigd door _ferry_ op 09-04-2007 19:46]

[TKoster]

Dat ziet er goed uit. Lekker strak afgewerkt ook. Jammer van de kwaliteit van het filmpje maar het is wel duidelijk hoe het er in het echt uitziet.

[_ferry_]

Ja, mijn telefoon flipt een beetje van het felle licht ofzo.

[Cyrus The Virus]

ik heb mijn behuizing ook klaar, heb alleen nog wat problemen met ghosting mijn fets hebben last van een rc tijd en als ik pulldowns gebruik gaan er ledjes branden die niet horen te branden( heb er al enkele kapotte leds uitgehaald.

[_ferry_]

Ik heb ook 2 kapotte, die helemaal niet oplichten. Gelukkig wel op de buitenste ring
Verder wil er soms nog wel eens 1tje zwakjes oplichten wanneer het niet moet, op het onderste vlak.

Misschien omdat ik de fet's geen pull down heb gegeven. En bij het minste of geringste kunnen ze natuurlijk al schakelen. Als het niet helpt ga ik me er niet druk om maken ook, het valt amper op, de led's die namelijk normaal oplichten zijn vele malen feller.

[Voor 6% gewijzigd door _ferry_ op 09-04-2007 22:58]

[DeKemp]

erg vet.

[Cyrus The Virus]

_ferry_ schreef op maandag 09 april 2007 @ 22:57:
Ik heb ook 2 kapotte, die helemaal niet oplichten. Gelukkig wel op de buitenste ring
Verder wil er soms nog wel eens 1tje zwakjes oplichten wanneer het niet moet, op het onderste vlak.

Misschien omdat ik de fet's geen pull down heb gegeven. En bij het minste of geringste kunnen ze natuurlijk al schakelen. Als het niet helpt ga ik me er niet druk om maken ook, het valt amper op, de led's die namelijk normaal oplichten zijn vele malen feller.

Dat is dus de ghosting waar ik ook last van heb, je moet eens meten (als je een scoop hebt) de uitgang van je P-channel als hij aanstaat en kijken of je dan ee RC tijd hebt of andere wazige verschijnslen. Ben wel benieuwd.


tip gebruik geen pull down, is alleen maar problemen

[Voor 3% gewijzigd door Cyrus The Virus op 10-04-2007 16:54]

[bazzzzzz]

zo ziet er geweldig uit! ik moet nogsteeds gaan programmeren:P

[_ferry_]

Okee, zal van de week eens kijken met de scoop. Het zijn bij mij N-channels Het meest zichtbaar is de onderste laag, wanneer de bovenste leds aan staan.

Pic->595->8x anode's->common cathode->N-channel fet->GND

[Cyrus The Virus]

jij hebt ze heel anders als mij staan, je kunt het met hardware niet oplossen alleen met software.

[Cyrus The Virus]

Heb nu ook een VU meter cool

[DikoBaken]

Ik vind deze how-to echt heel duidelijk en heb inmiddels ook al wat spullen in bestelling staan om wat te bouwen.

Het valt me op dat niemand het idee heeft kregen om de aansturing te vereenvoudigen door bijvoorbeeld 74HC08 AND poortjes te gebruiken. (je hebt dan wel 1 uitgang per kolom nodig dus ook meerdere chips)

Om bijvoorbeeld in een 5x5x5 kubus het middelste ledje te laten branden stuur je x=3, y=3, verdieping=3
Dit is mijn inziens overzichtelijker te programmeren dan kolom-13 + verdieping-3 aan te sturen.

Resultaat is hetzelfde, alleen de manier waarop lijkt mij in elk geval stuk eenvoudiger.

Ik ben echter nog niet zo lang bezig met electro. (Dit is ook mijn eerste post op GoT)
Dus het zou best kunnen dat ik hierboven iets uitleg wat om een of andere reden toch niet kan werken.

[bazzzzzz]

mischien is het inderdaad overzichtelijker programmeren maar hoe je het hardwarematig wil doen lijkt mij lastig je wilt dan de punten die eig het "uiteinde" zijn van een matrix opnieuw in een matrix zetten. De manieren waarop ik het kan bedenken dat het kan kosten veel meer tijd=lagere refreshrate. dus erg ideeaal is het niet volgens mij

[shag-me]

Wat heb je precies nodig voor het aansturen van een 5x5x5 Kubus?
Ik heb nog niets voor het programmeren van een pic..
Welke weerstanden gebruiken jullie?
mij leek de kubus zoals in de startpost wel goed..
Soldeer ervaring/apparatuur heb ik...

[bazzzzzz]

weerstanden moet je zelf uitrekenen aan de hand van hoeveel licht je wilt. bij een 5*5*5 kubus staat elke verdieping maar 1/5 van de tijd aan. Je mag dus meer stroom door de led laten lopen dan de 20ma die aanbevolen is. Neem iets van 60ma ofzow als je de volledige felheid wil benutten.

verder staat in de startpost een lijstje van wat ik heb gebruikt dat is een best goed uitgangspunt

[shag-me]

dus allemaal weerstandjes van 60 ma? Ik wilde idd uitgaan van de startpost

[bazzzzzz]

ik bedoel de weerstand zo berekenen dat er 60ma door het ledje loopt. maar 60ma is wel behoorlijk veel hoor. Dus dan moet je wel erg opletten met testen

[shag-me]

Is het dan verstandiger om wat minder te doen? bijvoorbeeld 50 ma? of branden ze dan te zwak als de stroom er 1/5 van een sec op komt te staan..

[bazzzzzz]

1/5 van 50ma is 10ma gemiddeld dat is wel genoeg. Zeker als je gewoon die standaard groene ledjes gebruikt die ik ook voor mijn eerste kubus gebruikt heb. Als je die gebruikt hoef je trouwens ook neit erg bang te zijn met testen, die dingen kunnen bijna overal tegen

[_ferry_]

Als ik een hele kolom aan zet, dus 8 ledjes die samen 20mA mogen opsnabbelen, dan zijn ze nog best fel. Je zou dus ook gewoon van 20mA uit kunnen gaan.

[Cyrus The Virus]

VU meter werkt goed nu

alleen is de A/D conversie denk ik te traag want je ziet de leds knipperen, maar moet ff kijken of ik dat op kan lossen.

Zal ook ff kijken of ik een fatsoenlijk filmpje kan maken.

[bazzzzzz]

_ferry_ schreef op maandag 16 april 2007 @ 17:16:
Als ik een hele kolom aan zet, dus 8 ledjes die samen 20mA mogen opsnabbelen, dan zijn ze nog best fel. Je zou dus ook gewoon van 20mA uit kunnen gaan.

bij mij valt het heel erg tegen (7 ledjes die samen 20ma krijgen) maar idd 50 a 60ma is ook wel weer aan de hoge kant. Daarom je kan beter zelf expirimenteren!

[Cyrus The Virus]

http://www.youtube.com/watch?v=j2yc8bMBgR4

Mijn led vu meter

[TKoster]

Cyrus The Virus schreef op dinsdag 17 april 2007 @ 14:33:
http://www.youtube.com/watch?v=j2yc8bMBgR4

Mijn led vu meter

Ziet er mooi uit, maar dat kan denk ik wel uitgewerkt worden. Bijvoorbeeld met fall-off(?) en elke kolom een andere frequentie.

[Cyrus The Virus]

TKoster schreef op dinsdag 17 april 2007 @ 16:14:
[...]


Ziet er mooi uit, maar dat kan denk ik wel uitgewerkt worden. Bijvoorbeeld met fall-off(?) en elke kolom een andere frequentie.

fall off zouw nog kunnen, maar elke kolom ander frequentie moet ik eerst een andere print maken waar band frequentie filters zitten

[shag-me]

dat uitproberen kun je toch gewoon met 1 weerstand en 1 ledje doen? Alleen je gaat uit van 1/5e.. dus je moet dan ff een weerstand hebben van 1/5e van je totaal natuurlijk

[Voor 44% gewijzigd door shag-me op 17-04-2007 23:29]

[surge_me]

@ _ferry_ waar heb je die leds vandaan? en wat kosten ze per stuk?

[TKoster]

Cyrus The Virus schreef op dinsdag 17 april 2007 @ 17:48:
[...]


fall off zouw nog kunnen, maar elke kolom ander frequentie moet ik eerst een andere print maken waar band frequentie filters zitten

Dat maakt het dan weer jammer dat het geen RS232 is, dan was het zo gedaan.

[Cyrus The Virus]

TKoster schreef op woensdag 18 april 2007 @ 13:44:
[...]


Dat maakt het dan weer jammer dat het geen RS232 is, dan was het zo gedaan.

je bedoelt gewoon op de PC doen, kan wel hoor via USB.

Alleen heb ik totaal geen ervaring in PC programma's maken.

[surge_me]

Cyrus The Virus schreef op dinsdag 17 april 2007 @ 17:48:
[...]


fall off zouw nog kunnen, maar elke kolom ander frequentie moet ik eerst een andere print maken waar band frequentie filters zitten

Als je een pic18 gebruikt, er zijn daar routines voor te vinden die FFT's kunnen trekken (en dan hoef je dus niet die bandfilters te bouwen) met de hardware multiplier in je PIC moet het dan geen probleem zijn om iets moois te maken....

[TKoster]

Cyrus The Virus schreef op woensdag 18 april 2007 @ 14:02:
[...]


je bedoelt gewoon op de PC doen, kan wel hoor via USB.

Alleen heb ik totaal geen ervaring in PC programma's maken.

Ik zou dat evt. wel kunnen doen in VB.

[shag-me]

Ik heb een programmeerbordje met rs232, van velleman.

[Cyrus The Virus]

TKoster schreef op woensdag 18 april 2007 @ 23:08:
[...]


Ik zou dat evt. wel kunnen doen in VB.

van mij mag ik wil dat ook nog eens gaan doen in Visual C of Visual Basic ben gister mee begonnen maar is allemaal nog wazig voor mij . keer eens een boek halen

surge_me schreef op woensdag 18 april 2007 @ 19:39:
[...]

Als je een pic18 gebruikt, er zijn daar routines voor te vinden die FFT's kunnen trekken (en dan hoef je dus niet die bandfilters te bouwen) met de hardware multiplier in je PIC moet het dan geen probleem zijn om iets moois te maken....

Ja ik heb en PIC18F4550 op 20MHz kristal lopen, maar heb je daar voorbeelden van FFT is toch forier reeks of niet ? (ben niet zo in de audio thuis).

[surge_me]

Heb er geen ervaring mee maar dit lijkt mij wel een goed artikel,

http://www.circuitcellar.com/library/print/0998/Lacoste98/

Voor de rest kan google je helpen, het is echter geen makkelijke materie.

FFT= Fast Fourier Transform, gelijk een Fourier transformatie, echter geoptimaliseerd voor de computer.

Je moet je frequentie spectrum in een aantal buckets onder verdelen (stukjes frequentie waarbinnen je het vermogen berkent) dus voor 0-20Khz kun je bijvoorbeeld opdelen in 7 (=aantal leds horizontaal) stappen van gelijke afstand (2.857Khz).

Je berkent dan het vermogen (met behulp van je FFT routine) in alle buckets en deelt het maximale vermogen dat je tegenkomt (eender welke bucket) door 7 (=aantal leds veriticaal). Nu weet je hoeveel vermogen/led je moet weergeven en kun je 2D de leds aansturen, 3D gaat soortgelijk maar is een stapje moeilijker en het ligt er precies aan wat voor een effect je wilt bereiken.

Let wel op: voor een 0-20Khz bereik moet je dus samplen op minimaal 40Khz (en neem nu maar wat meer omdat je geen oneindig stijle ingangsfilters kunt maken) houd misschien gewoon de cd frequentie aan van 44.1Khz.

[bazzzzzz]

mijn kubus heeft even in een hoekje gelegen maar hij werkt inmiddels. hij is dus 7*7*7 en 2 kleuren. Aansturing weer een pic 16f628 a maar die heeft eigenlijk te weinig geheugen. Ik kan nu maar 10 patronen er in kwijt, beetje weinig dus. Maar ik ga mijn routines nog wat efficienter maken dus straks moeten er een stuk of 15 inkunnen. Foto's plus filmpje volgt volgende week

[shag-me]

Heeft iemand hier een hex bestand met aansturing voor een 16f628?

[_ferry_]

surge_me schreef op woensdag 18 april 2007 @ 12:49:
@ _ferry_ waar heb je die leds vandaan? en wat kosten ze per stuk?

Van de SK.net actie, gewoon de diffuus blauwe.

shag-me schreef op maandag 23 april 2007 @ 12:09:
Heeft iemand hier een hex bestand met aansturing voor een 16f628?

Psst, dat is nogal hardware en effect afhankelijk, ofwel, je kan er nix mee.

[surge_me]

Sorry hoor maar heb je toevallig ook een linkje?

Er staan daar heel veel verschillende leds (3mm 5mm 10mm, etc) dat ik niet weet welke jij hebt?

Ze zien er iig mooi uit

[bazzzzzz]

deze lijkt mij dan he:

http://www.samenkopen.net/action_product/448813/931229

@surge_me je mag best mijn hex bestand hebben maar of je er iets aan hebt betwijfel ik. De .asm die je zelf aanpast werkt beter lijkt mij;) mail mar ff

[surge_me]

bazzzzzz schreef op dinsdag 24 april 2007 @ 09:48:
deze lijkt mij dan he:

http://www.samenkopen.net/action_product/448813/931229

Waarom die? er staan nog meer variaties tussen....

Bijvoorbeeld:
http://www.samenkopen.net/action_product/448813/179815
http://www.samenkopen.net/action_product/448813/116342
http://www.samenkopen.net/action_product/448813/297027

Waarvan die laatste een riant grote uitstraal hoek heeft, is dat wel wenselijk in zo'n cubus?

@surge_me je mag best mijn hex bestand hebben maar of je er iets aan hebt betwijfel ik. De .asm die je zelf aanpast werkt beter lijkt mij;) mail mar ff

Ik heb niets aan je code (ik gebruik een andere manier van aansturen van de leds, met een CPLD en als controller heb ik een pic18F4550 en 512 ledjes (8*8*8))

Ik vroeg ook niet om het hex bestand, maar ff zoeken op de vorige pagina leert dat dat gebruiker shag_me was (eindigd ook op "_me" dus vandaar de mixup zeker...)

[w1z13]

Je moet juist voor zo'n ledkubus leds hebben met een zo groot mogelijke uitstraalhoek, een nog betere optie is gewoon diffuse leds (zoals bazzzzzz ze heeft gebruikt in zijn 2-kleurenkubus), die schijnen namelijk van alle kanten zodat je goed ziet welke led er brandt.

[bazzzzzz]

die link die ik je gaf is de enige diffuse blauwe. De andere zijn gewoon in een heldere "behuizing" dat is een stuk minder mooi

[surge_me]

ok bedankt voor de tip van de difuse leds

[bazzzzzz]

graag gedaan:P

jullie hadden nog foto's tegoed:




even een simpele smiley in alle 4 de zijkanten gezet

[Voor 10% gewijzigd door bazzzzzz op 01-05-2007 15:06]

[DikoBaken]

Ik heb vraagje over het stukje code dat gebruikt word om het schuifregister te vullen.
Waar of hoe geef je in assembler aan welke poort data1 is?

Ik heb zelf nu een 4*4*4 kubus in elkaar zitten en ben nu et printje aan het maken voor de aansturing.
En omdat ik de datasheet van de uln2803 niet goed heb zitten lezen heb ik er al 2 opgeblazen. Pin 10 zou optioneel zijn.... maar is wel nodig om aan te sturen met 5 volt, anders blaas je de darlington op.

code:

main
movlw    b'00001000'
    call    schuifregister1
;-------------------------------------------------------------
schuifregister1
movwf    Var1        ; zet de waarde vanuit w in Var1. dit is het getal wat geklokt moet worden
        movlw    D'8'        ;zet de waarde 8 in het werkregister
        movwf    bits1        ;sla de waarde 8 uit w op in bits1 dis is het aantal bits wat ingeklokt moet worden
loop1
        rlf        Var1,1        ;rotate left trough carry en sla het resultaat op in Var1. Eerste bit zit nu in de carry 
        btfss    STATUS, C    ; lees de carry uit. Is carry= 1?
        bcf        data1        ;zo nee, zet de datalijn naar 0
        btfsc    STATUS, C    ; is carry 0?
        bsf        data1        ;zo nee data is 1

        bsf        klok1
        nop        
        bcf        klok1        ;bitje is nu ingeklokt

        decfsz    bits1,f        ;verlaag bits1 met één totdat die nul is
        goto    loop1        ; is bits1 0? dan "return" zo nee ga naar loop1
        return

klok1
    bsf        klokingang1            ;CLOCK pin hoog
    nop
    bcf        klokingang1
    return
latch
    bsf        latch1        ;latch is hoog dus resultaat zou te zien moeten zijn    
    call    delay_300ms        ; hier heb ik een vertraging gebruikt maar een nop
    bcf        latch1        ;werkt ook goed
    return

[Phalox]

Ik vond geen recenter topic.. dus zet ik het maar hier

Ik ben deze avond (welja, een aantal uurtjes geleden) begonnen met een 3*3*3 cube-je, het led-gedeelte is nu af.. maar nu de rest nog.

Ik vroeg me af waarom jullie allemaal zoveel weerstanden gebruiken. in theorie kan je alles over 1 weerstand laten gaan (moet wel ééntje zijn met veel Watt-jes ).
Als ik nu 3 weerstanden gebruik, elk op 1 laag, in plaats van 9 (elk op één rij en kolom).. wat is hier dan niet goed aan ? als ik nooit twee leds op dezelfde laag tegelijk laat branden, vormt dit toch geen probleem denk ik?
Morgen de elektronica verder uitwerken.. en dan de software. die lijkt me nog het moeilijkste

Een mooie howto (zegt iemand 2 jaar na datum )

ps: een paar afbeeldingen van mijn cube: http://s8.photobucket.com...Cube/?albumview=slideshow

[_ferry_]

Je zegt het zelf al, zolang je maar geen meerdere led's per laag tegelijk aan zet. Want dan moeten meerdere led's de stroom delen waardoor je dus variatie in intensiteit krijgt.
Mijn advies is dus om gewoon 9cent uit te geven en elke kolom te voorzien van een weerstand. Als je dan geen 2 lagen tegelijk aanstuurt zit je nooit met variatie van lichtintensiteit.

* _ferry_ staat er weer bij stil dat hij deel 3 van de how-to moet afmaken

[Phalox]

Deel 1:
Zo, ik heb al die 9 weerstanden achter m'n uln2803 gezet (en nog een extra npn transistor.. want de uln heeft maar 9 poorten). maar nu moet ik dus de lagen ook nog eens schakelen (3 lagen).
Hiervoor wou ik 3 PNP transistoren gebruiken.. maar dat werkt toch niet precies.

Wat doe ik fout ? NPN vind ik vrij eenvoudig PNP is iets moeilijker...



Je zou dan toch verwachten dat de laag +4,3 Volt krijgt in deze toestand ?

nvm, ergens iets verkeerd gedaan, en er moet GND op de schakellijn

Deel 2:


wat is er hier fout aan ? ik heb nooit een toestand die 0 Volt als resultaat geeft...

[Voor 30% gewijzigd door Phalox op 05-04-2008 21:10]

[ken536]

Zie de -0,3 maar als de 0

[Phalox]

Mjah, dat zou ik wel willen.. maar dat betekent, dat er stroom in de andere richting vloeit, en er over de led -0,3 Volt komt te staan.. hebben die dat wel graag ?

[virus.elektro]

-0,3 volt gaat wel goed hoor, als je het echt niet vertrouwt kan je er een gewone diode voor zetten.
ledjes kunnen meestal tegen iets van -5 volt

[Phalox]

Ik zal hier nog eens wat verder het topic kapen

Er zijn nog een aantal foto's bijgekomen.. de elektronica is af denk ik
http://s8.photobucket.com...Cube/?albumview=slideshow

Alleen m'n galva wisp wilt niet echt mee werken.. Ik probeer met bumblebee te programmeren.. geeft ie deze error als hij gaat controlleren of het bestand juist is geupload.

Error: Verify error at address 0x0008. Value in image is 0x81 and value in target is 0x00.

Morgen eens proberen of het met een nieuwere versie wél werkt.

[Voor 30% gewijzigd door Phalox op 07-04-2008 22:53]

[mace]

tokesnugerd schreef op maandag 07 april 2008 @ 22:53:
Ik zal hier nog eens wat verder het topic kapen

Er zijn nog een aantal foto's bijgekomen.. de elektronica is af denk ik
http://s8.photobucket.com...Cube/?albumview=slideshow

Alleen m'n galva wisp wilt niet echt mee werken.. Ik probeer met bumblebee te programmeren.. geeft ie deze error als hij gaat controlleren of het bestand juist is geupload.

Error: Verify error at address 0x0008. Value in image is 0x81 and value in target is 0x00.

Morgen eens proberen of het met een nieuwere versie wél werkt.

Ik weet niet of je het gelukt is, maar ik programmeer altijd met xwisp2, met bumblebee had ik alleen maar problemen.

xwisp2 heeft een handig "go" commando welke de chip erased, progt en verifieert.

xwisp2 is wel command line, dat dan weer wel.

[MrDummy]

http://www.youtube.com/wa...GKhFIujM4&feature=related
Blijft ook gaaf. Een RGB kubus.

Merk op dat ze hotglue stiften gebruiken als diffusors. Dat kunnen jullie ook doen!

[Phalox]

mace schreef op vrijdag 18 april 2008 @ 11:50:
[...]


Ik weet niet of je het gelukt is, maar ik programmeer altijd met xwisp2, met bumblebee had ik alleen maar problemen.

xwisp2 heeft een handig "go" commando welke de chip erased, progt en verifieert.

xwisp2 is wel command line, dat dan weer wel.

Heb al met alles geprobeerd (Bumblebee, Xwsip, Xwisp2 (met de goede firmwares)) blijkbaar doet ie het nu... wel, hij programmeert zonder een error te geven, maar die pic lijkt wel dood. Een andere pic doet net hetzelfde..

Dit project gaat even stilliggen, ik heb nogal veel ander werk...

[tomw]

Ik zou ook graag een 7*7*7 kubus maken. Kan iemand mij vertellen wat ik allemaal nodig heb?
Het is maar om zeker te zijn dat ik niets vergeet.

http://www.samenkopen.net/action/228396 daar ga ik alles bestellen.

Momenteel heb ik al
2*testprint
10 x 74HC595
400 leds

maar dat is natuurlijk nog niet alles.

[kippy]

tomw schreef op woensdag 16 juli 2008 @ 20:18:
Ik zou ook graag een 7*7*7 kubus maken. Kan iemand mij vertellen wat ik allemaal nodig heb?
Het is maar om zeker te zijn dat ik niets vergeet.

http://www.samenkopen.net/action/228396 daar ga ik alles bestellen.

Momenteel heb ik al
2*testprint
10 x 74HC595
400 leds

maar dat is natuurlijk nog niet alles.

De weerstanden en transistoren om het zaaktje aan te sturen. Een microcontroller, bijvoorbeeld een Mega 16 of 32.

[tomw]

ondertussen heb ik al het volgende, jammer dat je sommige componenten in zulke grote hoeveelheden moet kopen.

5mm LEDs 100x geel 20mcd Led €7,40
Experimenteer pcb's experimenteer printplaat, 100x160 mm €2,50
ICs en spannings regelaars 10 x 74HC595 €1,60
PIC's, IC's, AVR's 10 x kristal 20Mhz €1,-
PIC's, IC's, AVR's PIC16f877A €3,20
onderdelen 500 x 20pF ceramic €5,25
onderdelen 500 x 100nF ceramic €4,50
weerstanden 50 x 82 Ohm €0,35

Ik zou m'n leds opbouwen met dit principe:

http://veerboot.tweakblogs.net/blog/cat/201

met welk type IC/FET wordt links op die afbeelding gewerkt? Op die manier zou ik dus ook geen voorschakelweerstanden meer nodig hebben. Is er daarvan een model op die samenkopen site die daarvoor zal kunnen dienen?
http://www.samenkopen.net/action_products/228396

Zijn die transistors eigelijk wel nodig? Want als ik kijk op die onderste foto van de blog zie ik helemaal geen transistors.

[Voor 7% gewijzigd door tomw op 16-07-2008 22:05]

[kippy]

tomw schreef op woensdag 16 juli 2008 @ 21:46:
ondertussen heb ik al het volgende, jammer dat je sommige componenten in zulke grote hoeveelheden moet kopen.

5mm LEDs 100x geel 20mcd Led €7,40
Experimenteer pcb's experimenteer printplaat, 100x160 mm €2,50
ICs en spannings regelaars 10 x 74HC595 €1,60
PIC's, IC's, AVR's 10 x kristal 20Mhz €1,-
PIC's, IC's, AVR's PIC16f877A €3,20
onderdelen 500 x 20pF ceramic €5,25
onderdelen 500 x 100nF ceramic €4,50
weerstanden 50 x 82 Ohm €0,35

Ik zou m'n leds opbouwen met dit principe:

http://veerboot.tweakblogs.net/blog/cat/201

met welk type IC/FET wordt links op die afbeelding gewerkt? Op die manier zou ik dus ook geen voorschakelweerstanden meer nodig hebben. Is er daarvan een model op die samenkopen site die daarvoor zal kunnen dienen?
http://www.samenkopen.net/action_products/228396

Zijn die transistors eigelijk wel nodig? Want als ik kijk op die onderste foto van de blog zie ik helemaal geen transistors.

Die schuifregisters kunnen maar 10mA leveren, zeker als je de uitgang nog gaat PWMém houd je beina niets over. Het kan zijn dat hij geen tranzistors gebruikt heeft maar ULN2003's, transistor array's

[TommyboyNL]

Ikzelf heb een 7x7x7 LED matrix staan, met 7 stuks 74HC595 en 7 stuks ULN2803 (Je kan ook 7 stuks ULN2003 pakken. ULN2803 = 8 drivers in 1, ULN2003 = 7 drivers in 1) als kolomdrivers. Als laag drivers heb ik een stel dikke FETs gebruikt, welke weet ik zo snel ff niet. Ook zijn er uiteraard 49 voorschakelweerstanden gebruikt.

[tomw]

Hoe groot moeten die voorschakelweerstanden ongeveer genomen worden voor 5V voedingsspanning voor oranje led's?
Doordat er gemultiplext wordt moet er meer stroom door de led's en dus een kleinere voorschakelweerstand. Is 82 Ohm al laag genoeg?