berekenen van een for lus in een for lus


for lus1 = x1 to y1
teller1 = teller1 +1
    for lus2 = x2 to y2
        teller2 = teller2 + 1
    next
next

dit heb ik:
x1 = 10
y1 = 255
x2 = 1
y2 = 30

en dan krijg je:


for lus1 = 10 to 255
teller1 = teller1 +1
    for lus2 = 1 to 30
         teller2 = teller2 + 1
    next
next

nu zou ik graag willen dat de lus 2 altijd evenveel uitgevoerd word in het totaal dan even veel doet.

stel nu lus1 = 255
lus2 = 10
dan doet hij de teller2 2555 keer optellen.

nu wil ik ook als je lus1 op 10 zetten en lus2 op 20
zet de teller2 ook 2555 keer uitgevoerd wordt
ik weet dat ik dan bij y2 iets moet bijtellen.

y1 en y2 kan men instellen

2555 / y1 = y2 ?

dit gaat niet

for lus1 = x1 to y1
teller1 = teller1 +1
    for lus2 = x2 to y2
        teller2 = teller2 + 1
    next
next

x1 = 10
y1 = 255
x2 = 1
y2 = 30

stel nu dit.
y2*y1 = totaal
2555/y1 *y1 = totaal
2555 = totaal
dan gaat hij onafhankelijk Y2 wat ik dan ook instel.

((max-lus1 - waarde-lus 1)*max-lus 1)*(min-lus 1/ max-lus 1)/(10/waarde-lus2)

(min-lus 1/ max-lus 1) is een getal kleiner dan 1 en kan ik float in een for lus invoegen.
ik gebruik een 16F628
maar de uitkomst is een waarde die ik dan bij y2 moet bijtellen

Wat wil je nou precies doen?

Zonder het probleem echt te begrijpen, wil ik nog wel een suggestie doen: Bresenham lijn algoritme, werkt zelfs als het gewenste aantal iteraties van de inner loop niet deelbaar is door het aantal iteraties van de outer loop.

       
;deel uit hoofdprogramma
For groen = 0 To 255              ;groen optellen                                 
            For lus = 1 To eindwaarde       ;eindewaarde is instelbare. de snelheid.
                GoSub pwm1                  ;ga naar pwm1
                GoSub snelheidregenboog     ;ga naar berekining
            Next
          Next

snelheidregenboog:

     If druk1 = 1 And Hdruk1 = 0 And eindwaarde < 100 Then
        eindwaarde = eindwaarde + 1
     EndIf
     Hdruk1 = druk1  
     
     If druk2 = 1 And Hdruk2 = 0 And eindwaarde > 1 Then
         eindwaarde = eindwaarde - 1
     EndIf
     Hdruk2 = druk2
return

pwm1:

     PWM uitgroen, groen, 1
     PWM uitblauw, blauw, 1           
     PWM uitrood, rood, 1
Return

ik weet dat als ik bij de variable lus die 255 kan veranderen dan kan ik de max sterkte instellen. maar hij mag niet de binste lus sneller doen niet beinvloeden.

deel van regenboog effect

Ik snap er nog steeds niet veel van. Je komt hier met een oplossing die niet werkt, en je legt het probleem dat je probeert op te lossen met deze code, niet duidelijk uit.

Als ik het goed begrijp (maar dat betwijfel ik), wil je dat de variabele "groen" niet groter wordt dan een bepaalde waarde (dus de lus stoppen als groen bijvoorbeeld gelijk is aan 100), maar de tijd die hij nodig heeft om daar te komen, moet gelijk blijven?

In dat geval is Bresenham toch de meest elegante en universele oplossing, denk ik.

Stappenplan:

Je maakt een nieuwe teller voor de buitenste loop.

Elke keer dat je de buitenste loop doorloopt, tel je de maximale waarde voor groen op bij een totaal.

Zodra die totaalwaarde groter of gelijk is aan 255, trek je er 255 van af, en tel je 1 op bij de variabele groen.

Op die manier zou je zelfs meerdere kleuren door elkaar kunnen laten faden, met verschillende snelheden, richtingen, etc.

Houd er rekening mee dat de intensiteit van een LED niet lineair is.

heb het probleem omglost door bij de tweede lus bij te zetten 255/"waarde lus1" niet echt idiaal want als ik de insiteit verander duurd dat even voordat het echt gebeurd

Ik denk dat de door jou bedachte implementatie gewoon niet helemaal de oplossing is voor je probleem. Misschien even een stap terug dus en, zoals SparkyGSX al zei, het probleem duidelijk beschrijven.

Op 10 juni 2010 18:37:06 schreef wilske:

       
;deel uit hoofdprogramma
For groen = 0 To 255              ;kleursterkte die ik uitstuur optellen. maar ik wil 
;die 255 de variable "dimmen" geven 
;hierdoor kan deze minder hard laten opgloeien. 
;maar hij beinvloed mijn tweede lus veel te veel.
            For lus = 1 To eindwaarde       ;eindewaarde is instelbare. de snelheid. 
;(hoelang hij er over doet voordat hij vollig is
                GoSub pwm1                  ;ga naar pwm1
                GoSub snelheidregenboog     ;ga naar berekining
            Next
          Next
; deze lussen heb ik verschijdende keren achter elkaar
; hierdoor kun je een kleur laten opgloeien en daan weer afnemen
; soort van regenboogeffect

snelheidregenboog:

     If druk1 = 1 And Hdruk1 = 0 And eindwaarde < 100 Then
        eindwaarde = eindwaarde + 1
     EndIf
     Hdruk1 = druk1  
     
     If druk2 = 1 And Hdruk2 = 0 And eindwaarde > 1 Then
         eindwaarde = eindwaarde - 1
     EndIf
     Hdruk2 = druk2
return

pwm1:

     PWM uitgroen, groen, 1
     PWM uitblauw, blauw, 1           
     PWM uitrood, rood, 1
Return

Ja, ik snap gewoon niet wat nou je probleem nou is.

Kun je niet beter gewoon 1 waarde berekenen uit 2 variabelen? Dus het dim-effect een factor laten zijn voor de huidige kleurwaarde?

als ik eerst
for groen 0 to 255 laat gaan
en for lus 0 to 16
pwm zenden
next
next

en dan ga dimmen
als ik for groen 0 to 125 laat gaan
dat de for lus 0 tot 16
pwm zenden
next next

bij de tweede lus heb ik groen van 0 naar 125 doen, 0 naar half gedimt
dan beinvloed die mijn snelheid

en dat heb ik opgelost door op het moment
die 16 weg te doen en een berekening van te maken
16*255/125

hier door blijft die snelheid het zelfde. maar als ik nu de kleursterkte groen instel dan duurd dat even voordat het gebeurd,wat logies is want die moet eerst lus2 uitdoen. dus dit is geen goede oplossing.
ik zou dit graag op een andere manier schrijven maar weetn ogniet goed.