Ik heb knight rider scanner effect gemaakt met PIC16F628.
Het is gemaakt via JAL.
Maar het heeft nog geen PWM effect.
Hoe kan ik ermee beste proggen?
Had op internet opgezocht, zoals RGB LED.
Maar ik snap er niks van.
Hier is de code die ik gebruikt.
include 16f628_20
include jlib
pin_b3_direction = output
pin_b2_direction = output
pin_b4_direction = output
pin_b5_direction = output
pin_b6_direction = output
pin_b7_direction = output
pin_a0_direction = output
pin_a1_direction = output
pin_b3 = low
pin_b2 = low
pin_b4 = low
pin_b5 = low
pin_b6 = low
pin_b7 = low
pin_a0 = low
pin_a1 = low
var byte x = 1
procedure delay is delay_10ms(x)
end procedure
delay_10ms
var byte n = 0
forever loop
delay
n = n + 1
if n > 52 then n = 11 end if
pin_b3 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( n == 11 )|( n == 12 )|( n == 13 )|( n == 51 )|( n == 52 )
pin_b2 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( N == 13 )|( n == 14 )|( n == 15 )|( n == 16 )|( n == 48 )|( n == 49 )|( n == 50 )|( n == 51 )|( n == 52 )
pin_b4 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( n == 15 )|( n == 16 )|( n == 17 )|( n == 18 )|( n == 19 )|( n == 45 )|( n == 46 )|( n == 47 )|( n == 48 )|( n == 49 )
pin_b5 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( n == 18 )|( n == 19 )|( n == 20 )|( n == 21 )|( n == 22 )|( n == 42 )|( n == 43 )|( n == 44 )|( n == 45 )|( n == 46 )
pin_b6 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( n == 21 )|( n == 22 )|( n == 23 )|( n == 24 )|( n == 25 )|( n == 39 )|( n == 40 )|( n == 41 )|( n == 42 )|( n == 43 )
pin_b7 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( n == 24 )|( n == 25 )|( n == 26 )|( n == 27 )|( n == 28 )|( n == 36 )|( n == 37 )|( n == 38 )|( n == 39 )|( n == 40 )
pin_a0 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( n == 27 )|( n == 28 )|( n == 29 )|( n == 30 )|( n == 31 )|( n == 34 )|( n == 35 )|( n == 36 )|( n == 37 )
pin_a1 = ( n == 0 )|( n == 1 )|( n == 2 )|( n == 3 )|( n == 4 )|( n == 5 )|( n == 6 )|( n == 7 )|( n == 8 )|( n == 9 )|( n == 10 )|( n == 30 )|( n == 31 )|( n == 32 )|( n == 33 )|( n == 34 )
end loop
Ik heb PWM op gebasseerd van Branko Karaklajic gemaakt.
En nu gaan ze allemaal langzaam uitgaan.
Hoe krijg ik zover om 1 voor 1 aangaat en dan langzaam uitgaan?
Een voorbeeld wat ik bedoel.
50-100-70-50-30-10-0
include 16f628_20
include jlib
var volatile bit PWM_out_pin1 is pin_b2
var volatile bit PWM_out_pin1_direction is pin_b2_direction
var volatile bit PWM_out_pin2 is pin_b3
var volatile bit PWM_out_pin2_direction is pin_b3_direction
var volatile bit PWM_out_pin3 is pin_b4
var volatile bit PWM_out_pin3_direction is pin_b4_direction
var volatile bit PWM_out_pin4 is pin_b5
var volatile bit PWM_out_pin4_direction is pin_b5_direction
var volatile bit PWM_out_pin5 is pin_b6
var volatile bit PWM_out_pin5_direction is pin_b6_direction
var volatile bit PWM_out_pin6 is pin_b7
var volatile bit PWM_out_pin6_direction is pin_b7_direction
var volatile bit PWM_out_pin7 is pin_a0
var volatile bit PWM_out_pin7_direction is pin_a0_direction
var volatile bit PWM_out_pin8 is pin_a1
var volatile bit PWM_out_pin8_direction is pin_a1_direction
procedure PWM_OUT(byte in PWM, byte in TRA) is
var byte LoPWM
var byte HiPWM
PWM_out_pin1_direction = output
PWM_out_pin2_direction = output
PWM_out_pin3_direction = output
PWM_out_pin4_direction = output
PWM_out_pin5_direction = output
PWM_out_pin6_direction = output
PWM_out_pin7_direction = output
PWM_out_pin8_direction = output
assembler
local PWMa
local PWMb
local PWMtra
local PWMend
bsf status, status_rp0
movlw 0b_1000_0011
OPTION
bcf status, status_rp0
movf PWM, W
movwf LoPWM
sublw 0xFF
movwf HiPWM
PWMa:
bcf INTCON, intcon_t0if
movf HiPWM, W
movwf TMR0
PWMb:
bsf PWM_out_pin1
bsf PWM_out_pin2
bsf PWM_out_pin3
bsf PWM_out_pin4
bsf PWM_out_pin5
bsf PWM_out_pin6
bsf PWM_out_pin7
bsf PWM_out_pin8
call PWMtra
bcf INTCON, intcon_t0if
movf LoPWM, W
movwf TMR0
bcf PWM_out_pin1
bcf PWM_out_pin2
bcf PWM_out_pin3
bcf PWM_out_pin4
bcf PWM_out_pin5
bcf PWM_out_pin6
bcf PWM_out_pin7
bcf PWM_out_pin8
call PWMtra
decfsz TRA,f
goto PWMa
goto PWMend
PWMtra:
btfss INTCON, intcon_t0if
goto PWMtra
return
PWMend:
end assembler
end procedure
var byte n = 255
forever loop
pwm_out (n, 15)
n = n - 17
end loop
Op die manier geef ik het op om PWM sources te schrijven, want ik snap er nog niks van.
Maar misschien kan ik op deze manier laten werken door met condensator op uitgangspoorten van PIC aan te sluiten.
Zou het zo kunnen werken?
Ik ken JAL niet, maar niet
iedere poort van je PIC geeft
hardware PWM.
Je kan inderdaad een condensator
er tussen gooien om het zelfde
effect te bereiken.
Onzin post, niet goed opgelet, sorry 
[Bericht gewijzigd door JoWi op ]
RES
RES
Een stuk of 4 a 5 LED's een eigen PWM teller geven, die met dus 4 a 5 preset getallen instellen van vol naar zwak (experimenteren met verschillende pulsbreedtes), zodat je een "staart" krijgt te zien (eerst stilstaand de staart in beeld brengen), dan telkens een LED verder verplaatsen met een bepaalde vertraging (de voorgang snelheid van de staart)
Het kaatsen van de staart tegen de einden is wat lastiger, je moet de animatie stapje voor stapje volgen (ik gebruikte een gif animatie als voorbeeldje)
[Bericht gewijzigd door RES op ]