Vraag softwarematige pwm PIC

[Jetro2]

Ben dus aan het proberen een 3-kannaals pwm te maken, zodat ik een kleuren-LED verlichting kan maken. Heb al enkele topics gelezen, maar nog geen oplossing gevonden voor mijn probleem.

Voor de softw. pwm moet ik continu loopen door de pwm controle :

code:

procedure pwm is
        TempT2 = Tmr2
        if pwm1 < TempT2 then
           LED0 = low
        end if
        if pwm2 < TempT2 then
           LED1 = low
        end if
        if TempT2 < 0b0000_0010 then
           LED0 = high
           LED1 = high
        end if
end procedure

Wanneer ik nu veel andere code wil uitvoeren, mis ik pwm-cyclussen, en is de pwm niet mooi gelijkmatig. Zo zou ik bevoorbeeld graag hebben dat de pwm van sterkte verranderd als ik op een drukknop druk.
De volgende stap is om variërende programma's te laten lopen.

Een oplossing zou misschien zijn om de pwm frequentie te verlagen. deze is nu 1.22 KHz (prescaler 16,PR2 FF) Maar ik weet niet of dit mogelijk is.

info
PIC : 16F877A
Taal : JAL
prog : JALcc

Alle hulp/sample code is welkom

[DuDePrOdUcTiOnS]

Ik ben zelf bezig met een 26 kanaals PWM project (8xRGB, 2xwit) en ik heb het opgelost met een timer interrupt. ik heb de 'refreshrate' van de leds zo rond de 100 Hz lopen.
Dus elke keer als de timer verloopt en je in de interrupt routine komt alle pwm variabelen vergelijken met de counter en op het laatst de counter ophogen.

Ik gebruik zelf trouwens een DS89C420 microcontroller van Maxim.. momenteel nog op 20 MHz, maar als dat te weinig blijkt te zijn (ik zit nog in de ontwerpfase) ga ik naar 33 MHz..

[barber]

Op die PIC zitten 2 PWM Channels. Kan je die niet gebruiken, ipv het software matig doen?

[Jetro2]

Die interupt counter lijkt een goed idee, ik weet alleen niet of ik de counter zo kan instellen dat ik een frequentie van 100HZ kan krijgen (lijkt mij een goede freq om op te werken)
Heb ook nog niet met interrupts gewerkt....

2 PWMs is niet genoeg. RGB = ROOD GROEN BLAUW.
Met deze hoofdkleuren kan ik dan andere kleuren opbouwen, ander zou de ingebouwde pwm perfect zijn.

[naftebakje]

Waarom schrijf je in JAL?
Een pic werkt op ASM, dat zijn slechts 35 instructies die je moet kennen. Je moet inderdaad wat meer uitkijken wat je precies aan het doen bent, maar ik ben er 100% zeker van dat je een beter programma maakt in ASM (assembly, de codes in de datasheet).
Andere (hogere) programmeertalen worden enkel gebruikt om niet-tijdkritische programma's te maken.

Hoe ik dit weet? Ik heb een eindwerk gemaakt met PIC's, waarbij ik met 1 PIC een geschakelde voeding aanstuur, en tegelijkertijd een communicatie kan doen via DiSEqC (wel/geen toon van 4 kHz), die ook soms constant een toon van 4kHz op de uitgang heeft. Daarnaast is er ook nog allerhande communicatie (via I²C). Enorm tijdskritisch dus, en dit draait allemaal in 1 PIC (de 16F88), op de interne oscillator van 8MHz. Dit zou zeker niet te doen zijn in een hogere taal, en ik heb enorm veel werk gehad om de code snel genoeg te krijgen, de PIC was eigenlijk maar net goed genoeg om alles te kunnen.

Ik ben zelf ook wat aan het prutsen om RGB in een PIC te programmeren, maar ik heb nog niet echt tijd gehad om iets deftig op poten te zetten, zodra dit gedaan is maak ik hier wel een topic met mijn code. Op welk kristal draai je, ik test nu ff met de 16F627 op de interne 4MHz en dit moet zeker genoeg zijn.

Weet je dat je ook veel tijd kan besparen door de LED's op hogere stroom aan te sturen? Zolang de gemiddelde stroom niet boven het maximum gaat, je kan dus bijvoorbeeld de stroom verdubbelen, en een timerreeks kijken naar je knopjes (led's uit, dus interrupt ff af)), en dan een reeks kijken om je led's aan te sturen (interrupts aan). Ook al betwijfel ik of dit nodig zal zijn, als je goeie assembly code schrijft kan je (via interrupts) je LED's aansturen en tegelijkertijd naar je knopjes kijken.


Edit: interrupts zien er misschien niet zo lief uit, maar zijn erg gemakkelijk (in assembly toch), na je start (op PC adres 0) zet je een andere start (op PC adres 4) waar je je interrupt routine (wat je wil doen tijdens de interrupt) schrijft. Hoe dit te vertalen naar JAL moet je zelf uitzoeken. Dan kan je in de registers van je PIC (zie datasheet) instellen dat hij een interrupt moet geven op je timer overflow, en je timer goed instellen. Wanneer de timer dan overloopt (van 255 naar 0 gaan, als hij 8 bits is) zal de PIC (waar hij ook bezig was) eerst de interrupt routine doen, waarna hij weer verder gaat waar hij vandaan kwam (RETFIE, return from interrupt).
Zo kan je op een erg simpele manier ervoor zorgen dat een bepaalde taak in je programma steeds na dezelfde tijd uitgevoerd wordt.

[ Voor 21% gewijzigd door naftebakje op 21-11-2005 22:35 ]

[MichielPH]

Ben het volledig met naftebakje eens.Dit is inderdaad één van de programma's die in ASM geschreven moet worden.

Vergeet ook niet het W-register en die andere te backuppen in je interrupt!

Een goed voorbeeld is: http://home.versatel.nl/edithenwilliam/william.htm

[ Voor 22% gewijzigd door MichielPH op 22-11-2005 10:39 ]

[Lone Gunman]

Als assembly een te grote 'stap' is, kun je ook eens kijken naar proggen in C. Hi-tech software (http://www.htsoft.com) biedt gratis een C compiler aan (picc-lite) die bruikbaar is voor de pic16f628 en de pic16f877. Deze compiler integreerd netjes met mplab, zodat je ook de simulatie en debug mogelijkheden van mplab kunt gebruiken.

Softwarematig 3 pwm kanalen genereren kan namelijk makkelijk in C, hier heb je echt geen assembly voor nodig.
Je code zal er dan ongeveer zo uit zien:

C:

#include <pic.h>

void main()
{
   // stel oscillator registers in
  
   // stel adc registers in

   // stel gpio poorten in (bijvoorbeeld pin A0 als uitgang instellen)
   TRISA0 = OUTPUT;

   // stel de timer in (de waarde is bogus, en je 
   // moet nog meer instellen maar t gaat om t idee ;)
   T2CON = 0b10101010;

   // global interrupts aanzetten 
   GIE = 1;

   while(true)
   {
      // doe andere dingen 
      // (patroontjes genereren, knopjes samplen/deboucen, etc
   }
}

// de interrupt routine. 
// deze wordt automatisch aangeroepen als er een interrupt optreedt.
static void interrupt isr()
{
   // is de interrupt flag van de timer geset?
   if(TMR2IF) 
   {
      // zet hier je pwm code

      // reset de interrupt flag van de timer
      TMR2IF = 0;
   }
}

Bovenstaande is uiteraard niet compleet/niet werkend, maar het gaat om het idee hoe je zoiets mbv C kunt doen.

[ Voor 4% gewijzigd door Lone Gunman op 22-11-2005 20:09 ]

[Jetro2]

Heb momenteel een ander oplossing :

code:

Forever loop
if pwm > Teller then
   LED = High
else
   LED = low
end if

Teller = teller +1
if Teller == 0xFF then Teller = 0 (Niet echt nodig, teller overflowd en reset bij FF)
*extra code*
end loop

De tijd om de extra code uit te voeren maakt niet uit, een loop cyclus zal altijd even lang duren.
Om de led nu automatisch op-neer te laten dimmen, kan men volgende code toevoegen :

code:

If TijdTeller == 0xFF then      (* bepaalde tijd om teller te vullen, ander gaan de verranderingen te snel)
   If Dir = low then
      pwm = pwm + 3
   else
      pwm = pwm - 5
   end if
   TijdTeller = 0
   Delay_1us
end if
TijdTeller = TijdTeller + 1

If pwm > 0xF0 then   (* bij max pwm terug dimmen)
   Dir = high
end if
If pwm < 0x06 then   (* bij min pwm terug versterken)
   Dir = low
end if

Hier ga ik dus de pwm waarde verhogen of verlagen na een bepaalde tijd (instelbaar met de tijdteller) Door verschillende getallen te nemen die geen veelvoud van elkaar zijn zal de dimmer in verschillende snelheid op-neer dimmen, wat met meerdere pwm kanalen een willekeurig effect geeft.

Nu enkel nog wat Deftige RGB LEDs kopen, en enkel verschillende functies schrijven

[Jetro2]

Ben nog een probleem tegengekomen dat gevorderde JAL-kennis vereisd.

Functie 1
Als bla dan Functie selecteer
Functie 2
Als bla dan Functie selecteer

Functie selecteer
ALS Bla DAN
Functie 1
ANDERS
Functie 2

Het probleem is dat een functie moet voorkomen voor de code waar ze wordt opgeroepen.
Functie 1 moet dus voor Functie Selecteer komen, en visa versa.
Als ik door de handleiding snuffel vindt ik geen goto functie, kan men deze nog in asm maken in JAL? Of is er een andere mannier die ik volledig niet zie?

Ik weet dat er nu aangeraden worden om in asm te werken, maar dit wil ik toch nog uitstellen.

[naftebakje]

Is het niet zo dat je eerst je functies declareert (zodat je compiler deze kan invullen waar je functie X zet), en je dan een commando (start, org 0x000 of dergerlijke) geeft, waardoor hij vanaf dit commando het programma begint uit te voeren (en het bovenstaande met de functies en dergerlijke negeert). Bij asm is het zo, het zal wel ook zo zijn bij JAL. Als je eens ff zoekt vind je ws wel voorbeeldprogrammas in JAL geschreven, waarin je de juiste manier van werken ziet.

[Jetro2]

Dat is net het probleem, een van de functies wordt altijd na de ander gedeclareerd. En beide functies verwijzen naar elkaar.

[naftebakje]

Jetro2 schreef op woensdag 23 november 2005 @ 19:29:
Dat is net het probleem, een van de functies wordt altijd na de ander gedeclareerd. En beide functies verwijzen naar elkaar.

Dat zal niet werken. Je kan geen kruisverwijzingen gebruiken, de compiler kan dit niet vertalen naar code. Je zal een routine moeten gebruiken in het programma zelf, om dat op te lossen. Je probeert je programma zoveel te vereenvoudigen dat je het programma in de functies schrijft, daarvoor moet je routines gebruiken.
Als ik je voorbeeldje zie, dan ben je eindeloze lussen aan het maken waar ik ook het nut niet van inzie. In asm zou ik het volgende doen (afh van wat je doet natuurlijk, ik snap niet echt wat je zou willen doen, je wil in een functie zetten dat je ze zoms niet wil doen, kan je dat niet beter controleren voor je die functie aanroept?):

code:

START    org 0x000     ;hier begint het programma zelf, daarvoor worden de functies gedeclareerd.
main
      gewone progje
selecteer    
       ALS Bla DAN
       GOTO Functie 1
       ANDERS
       GOTO Functie 2
       GOTO main

functie1
       ALS bla dan GOTO selecteer

functie2
       ALS bla dan GOTO selecteer

[Jetro2]

De bedoeling is dat ik verschillende 'programma's' schrijf die de LEDs op andere manieren aansturen. In de programmas wordt gecontroleerd of er op de selectieknop gedrukt wordt, als dit zo is, springt men naar het selectieprogramma om daar het volgende programma aan te roepen.
De GOTO funtie mis ik dus echt in JAL

Ben al sterk aan het twijfelen om asm te hanteren, enkel de leertijd schrikt me af
Zijn er goede tutorials voor asm? Misschien moet ik er maar eens gewoon voor gaan

[naftebakje]

Op circuits online heb je een mooie tutorial (in het nederlands!), en verder staan in de datasheet alle 35 instructies uitgelegd. Microchip levert trouwens goeie startbestandjes om mee te beginnen, een "naam PIC".lst, die ervoor zorgt dat je alle registers met hun naam ipv hun geheugenlocatie kan aanspreken, en een .asm bestandje dat netjes toont waar je je programma moet zetten.
Het is eerst ff schrikken, maar binnen de kortste keren ben je ermee weg (ik heb in 3 maanden tijd een héél deftig eindwerk gemaakt, en vooraf had ik nog nooit een µP geprogged, dus leertijd is niet erg lang).

En ben je er echt zeker van dat er geen jump of goto of dergerlijke bestaat in JAL, want PIC's ondersteunen het springen zeker en vast.

Ik ben trouwens tot de conclusie gekomen dat om ongeveer op 100Hz aan te sturen, ik om de 10.000 instructie's een pwm cycle moet hebben gedaan (1.000.000 instructies/sec). Een resolutie van 255 wil zeggen 255 keer checken of de led's nog niet uit moeten, dus kom ik uit dat er 39 instructies tijd is om 1) mijn led's aan te sturen (gewenste met tellerwaarde vergelijken, eventueel uitschakelen) en 2) de rest van het programma uit te voeren. Dan heb ik (door afronding) na 255 keer geteld te hebben 55 instructies tijd om alles af te handelen (de gewenste waarden aanpassen, eventueel faden,...) en daarna een nieuwe pwm cyclus te starten, zo stuur ik mijn ledjes netjes op 100Hz aan.

Dat moet zeker lukken, doordat ik een interrupt gebruik moet ik in mijn "gewone" programma geen rekening houden met de PWM, alleen dat de uitvoersnelheid wat trager is (19 instructies in de interrupt, nog 20 over voor het gewone programma, dus een halvering van de snelheid). Dat is nog ruim voldoende om een babbeltje te doen met een PC (via de UART en RS232) en om een programma af te lopen.

[ Voor 56% gewijzigd door naftebakje op 24-11-2005 17:49 ]

[Jetro2]

Gebruik jij gewoon de MPLAB IDE van microchip zelf? of zijn er betere programma's in omloop?
De pic-tutorial van circuits online heeft me ooit overhaald om met microcontrollers te beginnen. Ik vind enkel da men niet diep ingaat op het programmeren.

Verder wil ik je al bedanken naftebakje, voor uw respons en hulp om deze noob in de wondere wereld van de PICs in te leiden

[Lima]

ik ben ook bezig met zo een project, het is wel al af maar erg omslachtig geprogrammeerd. Ik ben dus eignelijk niet tevreden over mijzelf.
Ik kan mijn 3 PWM kanalen niet apart aansturen, dus ik heb geen knoppen om bv van elk kanaal de sterkte te regelen.

Dus zoals naftebakje zegt, zou ik dan bv in mijn ISR de voorwaarden moet steken wat er moet gebeuren als ik bv op een knop duw, dus hier het verhogen of verlagen van mijn tellerstand.
Hierna de "body" en dus mijn programma waarin de tellers staan etc voor de 3 PWM kanalen. Maar die moeten dus alle drie na elkaar? Dus bv eerst het pwm kanaal voor rood, dan voor groen en dan voor blauw? Dus dan brand eerst groen met een bepaalde daarna blauw en bv rood niet (teller=0 ?)

En dan kan ik bv ook nog diezelfde knoppen die ik gebruik (6 voor elk kanaal 2) gebruiken voor andere dingen mee te doen in mijn programma's, door bv een variabele uit te lezen die onthoud in welk programma hij actief was en dan in de isr zegt wat hij nu moet doen?

En als dit allemaal klopt, hoe kom ja dan aan 6 ingangen met interrupt? Ik zie ergens een oplossing door alle schakelaars gewoon te latne uitlezne op elk ene poort en dan nog eens naar een interrupt ingang. Maar dan moet je zeker diode's plaatsen omdat andere alle uitgangen ook hoog worden ofzo iets...
Kan iemand me ff zeggen of ik het juist voorheb?

[naftebakje]

Jetro2 schreef op donderdag 24 november 2005 @ 19:03:
Gebruik jij gewoon de MPLAB IDE van microchip zelf? of zijn er betere programma's in omloop?
De pic-tutorial van circuits online heeft me ooit overhaald om met microcontrollers te beginnen. Ik vind enkel da men niet diep ingaat op het programmeren.

Verder wil ik je al bedanken naftebakje, voor uw respons en hulp om deze noob in de wondere wereld van de PICs in te leiden

MPlab vind ik persoonlijk erg handig, het is gratis en je kan erg goed simuleren (en de code wordt natuurlijk gekleurd, erg handig als je iets een naam geeft die niet mag gebruikt worden, bijvoorbeeld omdat het een instructie is, die wordt net als andere instructies blauw). Ik betwijfel of er andere programma's zijn die dit kunnen evenaren. De reden dat die tutorial niet diep ingaat op het programmeren is eenvoudig: er is niet veel over te zeggen. Je moet je id omzetten naar een werkwijze, als dat gelukt is kan je dat snel schrijven in de taal van je PIC.
Om te beginnen (voor elk programma trouwens, niet alleen je eerste) raad ik je aan eerst alle registers in te stellen. Zo moet je de berekening die ik al gemeld heb even doen, om te weten of je een prescaler voor je timer nodig hebt. Als je alle registers ingesteld hebt, weet je al hoe je programma eruit zal zien.
Geen dank, ik heb hier ook al hulp gekregen van anderen, dus moet ik ook iets terugdoen.

L i m a schreef op donderdag 24 november 2005 @ 19:11:
ik ben ook bezig met zo een project, het is wel al af maar erg omslachtig geprogrammeerd. Ik ben dus eignelijk niet tevreden over mijzelf.
Ik kan mijn 3 PWM kanalen niet apart aansturen, dus ik heb geen knoppen om bv van elk kanaal de sterkte te regelen.

Dus zoals naftebakje zegt, zou ik dan bv in mijn ISR de voorwaarden moet steken wat er moet gebeuren als ik bv op een knop duw, dus hier het verhogen of verlagen van mijn tellerstand.
Hierna de "body" en dus mijn programma waarin de tellers staan etc voor de 3 PWM kanalen. Maar die moeten dus alle drie na elkaar? Dus bv eerst het pwm kanaal voor rood, dan voor groen en dan voor blauw? Dus dan brand eerst groen met een bepaalde daarna blauw en bv rood niet (teller=0 ?)

Ik zou in de ISR (de interrupt) alleen de pwm routine steken, dus een tellertje dat tot 255 telt, in de interrupt doe ik teller+1, en vergelijk ik de gewenste waarde van R en G en B. Alledrie in 1 dus. (vb r 50/255 aan, dus teller = 50 dan rode led uit, hetzelfde voor G en

En dan kan ik bv ook nog diezelfde knoppen die ik gebruik (6 voor elk kanaal 2) gebruiken voor andere dingen mee te doen in mijn programma's, door bv een variabele uit te lezen die onthoud in welk programma hij actief was en dan in de isr zegt wat hij nu moet doen?

Voor de knoppen zou ik de code in het gewone programma (niet in de interrupt) zetten, want niemand kan een knopje op 100Hz in/uit drukken, terwijl de PWM wel 100Hz moet zijn. Ik denk trouwens aan 4 knopjes, 1 voor R,G,B en 1 die up/down kiest (weergegeven door een extra ledje).
Ik snap niet wat je bedoeld met variabelen laten uitlezen door knoppen?

En als dit allemaal klopt, hoe kom ja dan aan 6 ingangen met interrupt? Ik zie ergens een oplossing door alle schakelaars gewoon te latne uitlezne op elk ene poort en dan nog eens naar een interrupt ingang. Maar dan moet je zeker diode's plaatsen omdat andere alle uitgangen ook hoog worden ofzo iets...
Kan iemand me ff zeggen of ik het juist voorheb?

Je knoppen zijn niet tijdskritisch, geen interrupt dus. Je zal ze trouwens moeten vertragen, anders kan je nooit goed instellen, want 1* drukken zou de instelling teveel veranderen. Je kan voor elk knopje een variabele maken, zodra het knopje van een kleur ingedrukt wordt verhoog je de variabele van dat knopje met 1, bij een bepaalde waarde verander je de gewenste waarde van de PWM routine.

En dan ga ik nu aan het proggen, straks kan ik ws een eerste versie tonen, dat zal alles wel duidelijk maken.

[naftebakje]

Zo, de basis is gelegd. Ik heb de interruptcode (en de juiste instellingen) gemaakt en getest (via simulatie).
Je kan vanaf deze code je programma schrijven, je snapt ws heel snel wat ik allemaal doe, als je er even de datasheet bijhaald. Fine-tunen is natuurlijk nog niet gebeurd, en er is ook nog geen mogelijkheid voorzien om de waarde van de ledjes te regelen. (ik gebruik een RGB led met 2 blauwe led's intern, daarom gebruik ik 2 uitgangen voor blauw).

code:

; (C)naftie, 24 november 2005
    list    p=16f627    ; de PIC die ik gebruik is deze
    #include <P16F627.INC>

    errorlevel -302 ;dit voorkomt dat mplab overbodige errors geeft
; hieronder stel ik de PIC in, belangerijkste is _MCLRE_ON: reset werkt (anders kan je niet programmeren)
;_WDT_OFF: anders wordt hij automagisch gereset, _INTRC_OSC_NOCLKOUT : 4MHz interne klok. 
    __CONFIG        _BODEN_ON & _CP_OFF & _DATA_CP_OFF & _PWRTE_ON & _WDT_OFF & _LVP_OFF & _MCLRE_ON & _INTRC_OSC_NOCLKOUT
    
; De gebruikte macro's:

LED_AAN macro
    BSF PORTB,0 ;LED_ROOD
    BSF PORTB,1 ;LED_GROEN
    BSF PORTB,2 ;LED_BLAUW1
    BSF PORTB,3 ;LED_BLAUW2
    endm

LED_ROOD_UIT macro
    BCF PORTB,0 
    ENDM

LED_GROEN_UIT macro
    BCF PORTB,1 
    ENDM

LED_BLAUW_UIT macro
    BCF PORTB,2
    BCF PORTB,3 ;deze regel kan geschrapt worden als maar 1 blauwe led gebruikt wordt   
    ENDM

; De gebruikte variabelen:
    cblock  0x020   ; vrije plaats voor variabelen vanaf 20
    ROOD_GEWENST    ; de gewenste waarde voor rood  |(= duty-cycle in procent * 2,55)
    GROEN_GEWENST   ; de gewenste waarde voor groen |(kan van 0 tot 255 zijn)
    BLAUW_GEWENST   ; de gewenste waarde voor blauw |(met stappen van 1)
    TELLER  ; de tellerwaarde waarmee bovenstaande 3 vergeleken worden
    w_temp          ; backup voor W, nodig in interrupt
    status_temp     ; backup voor status, nodig in interrupt

    TEST        ; een variabele om in testjes te gebruiken (na te kijken tijdens simuleren met view>watch)
    endc    ; einde reeks variabelen
;de gebruikte constanten:
    ;porta: knopjes van mijn testprint, zodat ik weet wat waar zit.
SW1 equ .0  ;knopje up/down
SW2 equ .1  ;knopje rood
SW3 equ .2  ;knopje groen
SW4 equ .3  ;knopje blauw
    ;portb: LEDjes van mijn testprint, zodat ik weet wat waar zit.
LD1 equ .0  ; ledje rood
LD2 equ .1  ; ledje groen
LD3 equ .2  ; ledje blauw1  |--> er zitten 2 blauwe leds in mijn RGB ledje, een PIC  
LD4 equ .3  ; ledje blauw2  |       levert max 25mA, dus 2 poorten nodig.
LD5 equ .4
LD6 equ .5  ; aanduiding up/down

;____START_PROGRAMMA____________________________
    ORG 0X000   ; hier start de PIC na een reset zijn programma
    NOP         ; soms is het nodig dat hier een NOP (= niets doen) staat, voor debugtoestellen 
    GOTO    INIT    ; ga naar waar je programma begint, want op 0x004 staat de interrupt
 
;____INTERRUPT_CODE_____________________________
    ORG 0X004   ; als er een interrupt is, gaat hij naar hier
    movwf   w_temp  ; na de interrupt werkt het programma verder alsof er niets is gebeurd
    movf    STATUS,w    ; na de interrupt werkt het programma verder alsof er niets is gebeurd
    movwf   status_temp ; na de interrupt werkt het programma verder alsof er niets is gebeurd

; zorgen dat de volgende keer weer een interrupt komt.
    movlw   .255-.39    ; na 39 instructies terug interrupt.
    movwf   TMR0
    BCF     INTCON,T0IF ; de interrupt vlag van timerO clearen
    BSF     INTCON,GIE  ; de interrupt terug inschakelen

;hieronder de code om de PWM te doen: RGB uitschakelen indien gewenst, en na 255 keer: PWM_KLAAR
    MOVF    TELLER,W    ; de tellerwaarde in W zetten (om straks te vergelijken)
    SUBWF   ROOD_GEWENST,W  ; ROOD_GEWENST - TELLER (gewenste waarde bereikt,nul, dan led uit)
    BTFSS   STATUS,C    ; negatief, dan is carry 0 (zie datasheet bij subwf), dan volgende regel doen
    LED_ROOD_UIT    ; doe macro om led af te leggen.
    MOVF    TELLER,W    ; zelfde als bij rood
    SUBWF   GROEN_GEWENST,W
    BTFSS   STATUS,C
    LED_GROEN_UIT 
    MOVF    TELLER,W
    SUBWF   BLAUW_GEWENST,W
    BTFSS   STATUS,C
    LED_BLAUW_UIT 

    INCF    TELLER,f    ; verhoog teller met 1, als teller 0 wordt, sla volgende over
    BTFSC   STATUS,Z    ; als TELLER nul is, doe volgende regel
    goto    PWM_KLAAR   ; volledige PWM cyclus gedaan, afhandeling doen.

    movf    status_temp,w   ; na de interrupt werkt het programma verder alsof er niets is gebeurd
    movwf   STATUS  ; na de interrupt werkt het programma verder alsof er niets is gebeurd
    swapf   w_temp,f    ; na de interrupt werkt het programma verder alsof er niets is gebeurd
    swapf   w_temp,w    ; na de interrupt werkt het programma verder alsof er niets is gebeurd
    retfie                    ; return from interrupt, keer terug waarvan je kwam.

INIT    ; hier doe ik enkele instellingen, die bij het opstarten moeten gebeuren.
    BANKSEL TRISA   ;trisa zit in bank1
    movlw   b'11111111' ; op poort a allemaal ingangen
    movwf   TRISA
    movlw   b'00000000' ; op poort b allemaal uitgangen
    movwf   TRISB

    BSF OPTION_REG,PSA  ; geen prescaler voor timer0
    BCF OPTION_REG,T0CS ; stel timer0 in als timer (+1 per instructie)
    MOVLW   b'10100000' ; Timer0 interrupt aanleggen.
    movwf   INTCON

    BANKSEL TMR0    ;bank0
    CLRF    TMR0
    MOVLW   B'00000111' ;Disable Comparator module's
    MOVWF   CMCON

    CLRF    PORTB   ; alle uitgangen uit.
    
;____START_CODE_________________________________
MAIN    
    GOTO    MAIN

PWM_KLAAR
    nop 
    LED_AAN
    RETURN

END

[brinkdinges]

Ik vind dit een heel interessant topic. Ik heb een tijdje geleden de tut van CO doorgelezen en wil binnenkort toch maar eens echt gaan proggen. Ik kan nog geen antwoorden op vragen geven, maar ik vind het allemaal heel interessant om te lezen. Mijn doel wordt een heel aantal rgb leds aansturen, dus dit komt zeker van pas

[Jetro2]

Na een weekend verloren te hebben aan 'quality time' ben ik er terug klaar voor.
Het probleem is dat ik geen respons krijg van mijn pic...
simpele code zoals het volgende doet niks

code:

    org 00h
    bsf 03,5            ;bank 2
    clrf 86h            ;poortb als uitgang zetten
    bcf 03,5            ;bank 1
    movlw 0FFh
    movwf 06h
    end

Mijn pic draait op een resonator(kristal)? de congiguratie doe ik via het configure menu.

Is er nog iets elementair dat ik over het oog zie?!

[ Voor 4% gewijzigd door Jetro2 op 28-11-2005 21:15 ]

[naftebakje]

Ik heb even goed moeten kijken, wat je schreef was onleesbaar. Om het jezelf véél gemakkelijker te maken, kan je bovenaan je code een .INC bestandje toevoegen, dat je op de site van Microchip kan vinden (naam van je pic.INC) (ook vind je een voorbeeldbestandje, dat is erg gemakkelijk om van te beginnen, dan kan je ook daar de configuratiebits instellen, zie wat ik in het begin van mijn programma hierboven heb gedaan).

Je progje wordt dan:

code:

    list    p=16f627    ; de PIC die ik gebruik is deze, aanpassen naar de joue als het een andere is.
    #include <P16F627.INC>   ; Dit bestand moet bij het programma zelf opgeslagen zijn.

    errorlevel -302     ; dit voorkomt dat een (overbodige) error wordt gegeven.

    org 00h
    banksel TRISB            ;bank [s]2[/s]1 kiezen, door de bank te kiezen waar "TRISB" in zit
    clrf    TRISB              ;poortb als uitgang zetten
    banksel PORTB       ;bank [s]1[/s]
    movlw 0FFh
    movwf PORTB
    end

Dat ziet er goed uit bij jou, je maakt alle pinnen van PORTB uitgang, en zet ze allemaal op '1'. Je vergeet wel iets belangerijks: je programma start op adres 0 (org 00h), maar de interrupt code moet vanaf adres 4 beginnen (ook al gebruik je gaan interrupts), das 1 aanpassing.
Ten tweede is het raar dat je je programma niet in een lus zet, na 1 keer gepasseerd te hebben is de code gedaan. Dat kan een probleem zijn, maar dat weet ik niet zeker.

Ik pas je code dan aan (ik zet de configuratie bij INIT, en het programma zelf bij MAIN, dit is gewoonte, maar maakt het ook duidelijker):

code:

    list    p=16f627    ; de PIC die ik gebruik is deze, aanpassen naar de joue als het een andere is.
    #include <P16F627.INC>   ; Dit bestand moet bij het programma zelf opgeslagen zijn.

    errorlevel -302     ; dit voorkomt dat een (overbodige) error wordt gegeven.

    org 00h
        goto   INIT

        org    04h
;hier kan een interrupt komen, zie als voorbeeld mijn bovenstaande code
       retfie 

INIT  ;hier zet ik alle instellingen en beginvoorwaarden gegroepeerd
        banksel TRISB            ;bank [s]2[/s]1 kiezen, door de bank te kiezen waar "TRISB" in zit
    clrf    TRISB              ;poortb als uitgang zetten
    banksel PORTB       ;bank [s]1[/s]

MAIN  ;dit is de code zelf
    movlw 0FFh
    movwf PORTB
        goto   MAIN
    end

Zo, dat zou het moeten zijn. Het is wel wat verlengd, maar waarschijnlijk begrijp je wel alles wat ik gedaan heb (en vind je het gemakkelijker om PORTB te gebruiken, ipv een cijfertje).

Edit: voor ik het vergeet, is je oscillator goed gekozen? Nu is hij ingesteld om een extern kristal te gebruiken, mss wil je de interne klok gebruiken, dan moet je _INTRC_OSC_NOCLKOUT kiezen.

Edit 2: Ik zie dat je MPlab gebruikt (die is idd het gemakkelijkste), daarmee kan je builden (dit heb je al gevonden veronderstel ik). Weet je dat je dan ook kan simuleren? Dit doe je met het "debug" onderdeeltje, bovenaan met die blauwe pijltjes. Het middenste knopje (step into) is handig, dat laat je programma regel per regel aflopen. Door View>7 Watch te klikken, krijg je een venster erbij, waarin je de waarde van de registers kan bekijken (dan zie je netjes de TRISB en PORTB veranderen), dat kan erg handig zijn om te testen.

[ Voor 15% gewijzigd door naftebakje op 28-11-2005 21:57 ]

[Jetro2]

Ik hab al een meer 'ingewikkeld' programma, maar had rap dit kleine geschreven om te testen.
I hate to say this : Ik vindt de *pic*.inc bestanden niet op de microchip site

De oscilator moet ingesteld staan op kristal. De aansluiting is goed want hij werkte immers ook met JAL.

Het debuggen lukt goed, als ik altijd met step into werk zie ik hem de waarde van poort B (06h ofzo) verranderen. Waarschijnlijk heeft het met de instellingen te maken, welke ik hopelijk wel beter in orde zal krijgen met het .INC-bestandje.

De pics die ik gebruik zijn de 16f628A en de 16f877A

ps: Ik ben op de hoogte van mijn vele spellingsfouten,ik heb ooit genoeg tijd verspild aan spelling op school

[naftebakje]

Zoals ik nu heb gezien, waren er geen fouten in de instellingen. Wel in de opbouw van de code dingen anders dan ik ken, en die misschien niet mogen.
Probeer eens mijn code te compileren en te programmeren, dat zal hopelijk wel werken.

De .INC files zitten blijkbaar in de mplab installatiefolder, onder MCHIP_TOOLS. Voorbeeldjes vind je in de map EXAMPLE.

[Lima]

naftebakje,
bedankt voor je prog!!!
Maar hier en daar snap ik toch nog dingen niet.
Je steekt gans je programma in je isr lijnen, en zou dan in je main (die nu een oneindige loop is) je knoppen laten uitlezen.
Maar als je een knop duwt leest hou toch maar een keer zijn isr lijnen en gaat daarna weer naar main, dus dan doorloopt hij zijn programma maar een keer en ga ik men led's niet eens zien oplichten.
Maar ik zie wel staan dat je zogezegd zorgt dat er weer een interrupt komt. Zeg je daar dat hij telkens hij weer aan je main programma wil beginnen hij je isr moet doorlopen? Dat met die flag snap ik. Als de flag 1 is kan je pas weer een interrupt veroorzaken. De andere instructies kloppen waarschijnlijk wel (die twee erboven van die zogezegde 39 instructies???).
Stel nu dat dit klopt, als ik dan op een knop duw die een interrupt geeft, dan zal hij toch meteen een neiuwe interrupt veroorzaken om dat mijn flag alweer op 1 staat? dus dan geraakt hij niet voorbij die lijnen vooraleer ik de knop loslaat (of de variabele die uitgelezen word 0 is)

Ook zeg je na je programma voor je pwm kanaal leds aan. Maar waarom doe je dat als ik vragen mag? Dat snap ik niet goed.
Je zet je tellers standaard op 255 en laat er 1 bij of op tellen naargelang welke knop er werd ingeduwd.dus je variabelen bepalen hoelang elke led uit is. (met rood gewenst - teller bv)

Maar dan zeg je leds aan na je isr. Dus als hij in je main programma zit, dan blijft hij alle led's uitsturen?
Ow ik lees net dat je alle uitgangen op nul zet op het einde van je isr. Maar dan nog snap ik het niet waarvoor je dat doet. Laat je alle led's zogezegd continue aan en bepaal je hoe sterk je ze dimt? Door de variabele gewenste waarde- teller?

Ik hoop dat je me nog even verder helpt. Ik heb echt al superveel "studiewerk" verricht voor te kunnen programmeren, ik zou het dan ook graag snappen zodat ik in de tekomst beter en vooral gestructureerder kan proggen.

edit: ik zou miss beter ook leren typen, had me ook een hoop werk gespaard.

[ Voor 4% gewijzigd door Lima op 30-11-2005 00:12 ]

[naftebakje]

Lima, je bent op de goeie weg, maar bent er even van afgeweken. Ik raad je aan eens de datasheet van de PIC die ik gebruik te lezen, en dan vooral van de interrupts en van Timer0, en eens te kijken welke instellingen ik maak (dan zal je helemaal snappen hoe het allemaal werkt, het is heel simpel eenmaal je het doorhebt, ik heb er me ook door moeten worstelen )

1) De mainlus is inderdaad nu een oneindige lus (das altijd zo bij een PIC, je moet je prog blijven uitvoeren) waarin nu niets gebeurd, daarin voeg je alle code toe die je wil uitvoeren. (bijvoorbeeld via de UART communiceren, de gewenste waarden aanpassen, knopjes uitlezen,...)

2) Op een knop drukken, hoeft bij een PIC helemaal geen interrupt te zijn (bij de 627 kan je maar 4 pinnen met een interrupt gebruiken), meestal zal je "pollen". Als op een ingang een '1' of een '0' staat, wordt de overeenkomstige bit in het register van die poort ook op '1' of '0' gezet. Door in je mainlus te kijken naar die bit's (pollen noemt men dat), kan je zien of er op de knop wordt gedrukt, en kan je overeenkomstige acties ondernemen.

3) Als het niet door de knoppen is, hoe komt ie dan in zijn interrupt routine? Door Timer0, wanneer deze overflowt (van 255 naar 0 gaat), dan (heb ik ingesteld) is er een interrupt. Dit wil zeggen dat hij springt naar adres 0x04, das waar de interrupt routine staat. Hij voert eerst deze code uit, tot hij bij "RETFIE" komt, dan springt hij terug naar waar hij vandaan kwam (ergens in de mainlus) en gaat hij verder met het uitvoeren van de mainlus alsof er niets gebeurd is.
Timer0 verhoogt met 1, elke kloktik. Ik wil elke 39 kloktikken in de interrupt geraken (zie berekening in een hogere post), dus zet ik in de interruptroutine de Timer0 op 39 kloktikken voor de overflow (die na waarde 255 komt).

4) Hoe doet ie nu de aansturing van die rgbLED?
Erg simpel: elke 39 kloktikken kom ik in de interrupt (volgt uit 3), hierin laat ik een tellertje telkens 1tje verhogen. Wanneer het tellertje op 255 komt, zet ik het weer op 0, en zet ik de led's aan. Wil ik dat de led 0% van de tijd brand, staat in de gewenste waarde 0, en zal de LED direct uitgeschakeld worden. Staat hier 170 in, zal die ongeveer 50% branden (na 170 keer 39 kloktikken uit), en zo verder. Dat had je inderdaad goed begrepen, door gewenste waarde met teller te vergelijken.

Dan nog een laatste cadeautje, met name mijn code die ik gebruik om met de knopjes te kunnen testen. Ik gebruik een knopje up/down (met indicatieled), ingedrukt = down denk ik. Daarnaast de 3 knopjes voor RGB, die erg simpel ontdenderd (en tegelijkertijd vertraagd) zijn, als de PIC 200 keer heeft gezien dat de knop ingedrukt is, dan pas wordt de gewenste waarde aangepast.
Let wel op: vooral dit stuk is een van de vele mogelijke oplossingen. Het kan ongetwijfeld beter/anders opgelost worden. En wees er trouwens maar zeker van dat er nog fouten/kleine onjuistheden zitten in mijn code (ook al werkt ze in mijn PIC), dat is altijd zo met een eerste versie (mijn timing is denk in niet in orde, de led volledig doven lukt niet, ik heb er ook nog niet naar gekeken).

code:

MAIN
    CALL    KNOPJES
    GOTO    MAIN

PWM_KLAAR
    LED_AAN
    RETURN

KNOPJES ;Hier lees ik de knopjes uit, en doe ik er iets mee
    BCF     PORTB,5 ;led up/down uit
    BTFSC   PORTA,0 ;wordt knop up/down ingedrukt?
    BSF     PORTB,5 ; dan led up/down aan   

    btfsc   PORTA,1
    INCF    R_KNOP,f
    MOVLW   .200    ; na 200 passages (==> vertraging),
    SUBWF   R_KNOP,W    ; waarbij op de knop wordt gedrukt
    BTFSC   STATUS,C    ; dit is het kijken of de 200 al gehaald is
    CALL    R_AANP      ; moet de waarde aangepast worden

    btfsc   PORTA,2
    INCF    G_KNOP,f
    MOVLW   .200    ; na 200 passages (==> vertraging),
    SUBWF   G_KNOP,W    ; waarbij op de knop wordt gedrukt
    BTFSC   STATUS,C    ; dit is het kijken of de 200 al gehaald is
    CALL    G_AANP      ; moet de waarde aangepast worden

    btfsc   PORTA,3
    INCF    B_KNOP,f
    MOVLW   .200    ; na 200 passages (==> vertraging),
    SUBWF   B_KNOP,W    ; waarbij op de knop wordt gedrukt
    BTFSC   STATUS,C    ; dit is het kijken of de 200 al gehaald is
    CALL    B_AANP      ; moet de waarde aangepast worden
    RETURN

R_AANP
    CLRF    R_KNOP
    BTFSS   PORTA,0 ; als knop down/up niet ingedrukt wordt
    INCF    ROOD_GEWENST,f  ;up
    BTFSC   PORTA,0 ; als knop down/up ingedrukt wordt
    DECF    ROOD_GEWENST,f  ;down
    RETURN

G_AANP
    CLRF    G_KNOP
    BTFSS   PORTA,0 ; als knop down/up niet ingedrukt wordt
    INCF    GROEN_GEWENST,f ;up
    BTFSC   PORTA,0 ; als knop down/up ingedrukt wordt
    DECF    GROEN_GEWENST,f ;down
    RETURN

B_AANP
    CLRF    B_KNOP
    BTFSS   PORTA,0 ; als knop down/up niet ingedrukt wordt
    INCF    BLAUW_GEWENST,f ;up
    BTFSC   PORTA,0 ; als knop down/up ingedrukt wordt
    DECF    BLAUW_GEWENST,f ;down
    RETURN

LED_BLAUW_UIT ; alleen nodig omdat ik 2 blauwe led's gebruik.
    BCF PORTB,2
    BCF PORTB,3
    return

    END

[_ferry_]

Phoe, ik ben ook bezig met zoiets, maar mijn ervaring is nog erg laag lijkt me namelijk leuk om een RGB led aan te sturen welk ik vervolgens langzaam kan laten faden, of juist op 1 bepaalde kleur. DMV knopjes. Maar ik denk dat ik begin met knopje 1 = output 1 hoog of laag, knopje 2 = output 2 hoog of laag enz. daarna ga ik het langzaamaan uitbreiden. De bedoeling is om 1 muur van mijn kamer zo in verschillende kleuren uit te lichten.

Ik heb overigens de velleman programmer gekocht, werkt prima

[ Voor 10% gewijzigd door _ferry_ op 30-11-2005 21:12 ]

[naftebakje]

_ferry_ schreef op woensdag 30 november 2005 @ 21:11:
Phoe, ik ben ook bezig met zoiets, maar mijn ervaring is nog erg laag lijkt me namelijk leuk om een RGB led aan te sturen welk ik vervolgens langzaam kan laten faden, of juist op 1 bepaalde kleur. DMV knopjes. Maar ik denk dat ik begin met knopje 1 = output 1 hoog of laag, knopje 2 = output 2 hoog of laag enz. daarna ga ik het langzaamaan uitbreiden. De bedoeling is om 1 muur van mijn kamer zo in verschillende kleuren uit te lichten.

Ik heb overigens de velleman programmer gekocht, werkt prima

Ik heb ook die velleman progger, inderdaad erg leuk speeltje om mee te beginnen (door de LEDjes en de knopjes die al voorzien zijn), en om verder mee te ontwikkelen (ICSP connector).

Ik kan je aanraden om te beginnen met MPLAB, en eventueel te beginnen op basis van het stukje code dat ik voor Jetro2 herschreef (dat 2e stukje, 22 regels). Het is het gemakkelijkste als je meteen een duidelijk systeem aanhoud, en die 16F627.INC maakt het erg gemakkelijk om dingen rechtstreeks uit de datasheet te programmeren.
Veel succes.

[Jetro2]

Blijkbaar zit het probleem nog ergens in ocsilator bij mij.
Tijdens mijn testen begon het ledje ineens te branden...
Nu merk ik als ik met mijn vingers wat met de resonator speel, na een tijdje het programma toch wordt uitgevoerd Men zou kunnen denken dat de resonator stuk is of slecht contact maakt, maar als ik een van de vorige JAL-programmas laad, dan werken die wel...

Aangezien deze pic geen interne ocsilator heeft, veronderstel ik dat hij in RC mode staat ofzo, en door mijn vingers maakt ik kleine 'storingen' die als kloksignalen worden aanzien.
My code

code:

    list    p=16f877A
    #include <P16F877A.INC>
    errorlevel -302
    __CONFIG    _BODEN_ON & _CP_OFF & _PWRTE_OFF & _WDT_OFF & _LVP_OFF & _XT_OSC

        org 00h
        nop
        goto INIT

        org 04h
        nop
        retfie

INIT
;       banksel TRISB       => door twijfel eventjes de oude manier gedaan.
        bsf 03h,5
        clrf TRISB      ;poortb als uitgang zetten
;       banksel PORTB
        bcf 03h,5
        
MAIN
        movlw 03h
        movwf PORTB
        goto MAIN
        end

[naftebakje]

@Jetro2: neem even de datasheet op blz 145, tabel 14-1. Als je resonator op 8 of 16MHz werkt, moet je de PIC als HS instellen, is dat het geval?

[_ferry_]

naftebakje schreef op woensdag 30 november 2005 @ 22:14:
[...]


Ik heb ook die velleman progger, inderdaad erg leuk speeltje om mee te beginnen (door de LEDjes en de knopjes die al voorzien zijn), en om verder mee te ontwikkelen (ICSP connector).

Ik kan je aanraden om te beginnen met MPLAB, en eventueel te beginnen op basis van het stukje code dat ik voor Jetro2 herschreef (dat 2e stukje, 22 regels). Het is het gemakkelijkste als je meteen een duidelijk systeem aanhoud, en die 16F627.INC maakt het erg gemakkelijk om dingen rechtstreeks uit de datasheet te programmeren.
Veel succes.

Thanks voor de info
Ik ben begonnen met de demo2 die bij de software geleverd zit, die heeft dus een timertje, en dmv de 4 knopjes kun je 4 programma's kiezen (looplichtjes enzo). Daarbij ga ik dan de programma's en timer veranderen zodat ik ledjes PWM kan dimmen. De timer heb ik dus al flink versneld.

code:

EFFECT_1    BTFSC   PORTA,SW1
        GOTO    EFFECT_1
E1      MOVLW   B'00111000' ; led 1 tm 3 aan
        MOVWF   PORTB
        CALL    DELAY_ROUTINE
        MOVLW   B'00111111' ; led 1tm 6 aan
        MOVWF   PORTB
        CALL    DELAY_ROUTINE
        GOTO    E1

Dit heb ik dus staan, je ziet dan dus de ene helft continu branden, de andere helft knippert heel snel als je goed kijkt, maar branden nog steeds even fel. maargoed, dat vind ik wel een uitdaging beetje met de tijd en snelheid knoeien

[Jetro2]

naftebakje schreef op woensdag 30 november 2005 @ 22:33:
@Jetro2: neem even de datasheet op blz 145, tabel 14-1. Als je resonator op 8 of 16MHz werkt, moet je de PIC als HS instellen, is dat het geval?

Was inderdaad het probleem (20MHZ)

Nu kan het echte werk beginnen

[_ferry_]

Phoe, dat PWM is z makkelijk nog niet, heb hetgeen van die william RGB led gemaakt, werkt uiteraard, maar het dan nog begrijpen is een 2e stap Wel leuk om er mee bezig te zijn BTW

[ Voor 13% gewijzigd door _ferry_ op 01-12-2005 20:52 ]

[Paul]

Naftebakje:
Kun je die error niet oplossen? errorlevel op iets anders dan de miereneukstand is niet goed

De Watchdog timer zet je uit, maar de brownoutdetectie zet je weer wel aan?
Toegegeven, watchdogreset aanroepen kost je een instructie, maart zorgt er wel voor dat je uC blijft lopen (-> gereset wordt mocht hij onverwachts vastslaan)

Een PIC loopt op 2V nog wel. Je brownout-reset kickt in bij 4V ongeveer, terwijl de hardware die er hier aanhangt weerstandjes en ledjes) die brownout gewoon overleven -> niet gereset hoeven te worden.

[naftebakje]

Paul Nieuwkamp schreef op donderdag 01 december 2005 @ 21:30:
Naftebakje:
Kun je die error niet oplossen? errorlevel op iets anders dan de miereneukstand is niet goed

De Watchdog timer zet je uit, maar de brownoutdetectie zet je weer wel aan?
Toegegeven, watchdogreset aanroepen kost je een instructie, maart zorgt er wel voor dat je uC blijft lopen (-> gereset wordt mocht hij onverwachts vastslaan)

Een PIC loopt op 2V nog wel. Je brownout-reset kickt in bij 4V ongeveer, terwijl de hardware die er hier aanhangt weerstandjes en ledjes) die brownout gewoon overleven -> niet gereset hoeven te worden.

Heb je het over de error van "errorlevel -302 ;dit voorkomt dat mplab overbodige errors geeft"? Ik ken de exacte oorzaak niet, maar MPLAB kan blijkbaar niet (goed) detecteren in hoeverre je in de juiste bank zit (banksel, van de registers in het geheugen). Daardoor wordt er steeds een warning gegeven dat je in de verkeerde bank zit, ook al zit je wel in de juiste bank. Microchip zelf raad dan ook aan om die regel in te voeren, om die error niet te hebben.
De oplossing zou zijn om zelf een programma als MPLAB te schrijven, maar dat zie ik niet zitten

Die watchdogtimer heb je maar nodig als je een slecht programma maakt, is mij verteld op mijn eindwerkbedrijf. Als je programma opeens (door een programmeerfout) vastloopt, kan je dat beter oplossen door je code te verbeteren, dan een watchdogtimer te gebruiken. Ik heb een heel lang en ingewikkeld programma geschreven, en nooit is er een PIC vastgelopen, dus ik zie het nut er niet van in. Die brown-out staat standaard aan, en aangezien ik geen zin heb om de reset netjes aan te sluiten (RC-netwerkje zodat ie in reset blijft tijdens opstarten, met diode die bij spanningsverlies hem ook doet resetten) mag die voor mijn part aanblijven, kwaad kan het niet. En als ik een te zwakke voeding maak, weet ik dat dan ook meteen

[Paul]

naftebakje schreef op donderdag 01 december 2005 @ 22:04:
[...]

Microchip zelf raad dan ook aan om die regel in te voeren, om die error niet te hebben.

Ah, ok Dan nog zou ik hem tijdens development en debuggen enzo toch weglaten, wie weet hoeveel errors je nu nog meer niet ziet

Die watchdogtimer heb je maar nodig als je een slecht programma maakt, is mij verteld op mijn eindwerkbedrijf. Als je programma opeens (door een programmeerfout) vastloopt, kan je dat beter oplossen door je code te verbeteren, dan een watchdogtimer te gebruiken.

Bugs moet je oplossen ja. Maar eenmaal in productie kun je volgens mij beter een apparaat hebben dat zichtzelf reset dan een apparaat dat om de zoveel tijd doodgaat waarna je hem handmatig kan gaan resetten

[naftebakje]

Paul Nieuwkamp schreef op donderdag 01 december 2005 @ 22:16:
[...]

Ah, ok Dan nog zou ik hem tijdens development en debuggen enzo toch weglaten, wie weet hoeveel errors je nu nog meer niet ziet

Die "-302" specificieert enkel de warning van een verkeerde bank in het geheugen, dus alle andere errors worden wel weergegeven, daar ben ik 99.9% zeker van.

[...]
Bugs moet je oplossen ja. Maar eenmaal in productie kun je volgens mij beter een apparaat hebben dat zichtzelf reset dan een apparaat dat om de zoveel tijd doodgaat waarna je hem handmatig kan gaan resetten

Mijn eindwerkbedrijf heeft een dusdanige expertise dat zij nu samenwerken met een amerikaans bedrijf dat een nieuwe chip aan het ontwikkelen is, en de door hun gemaakte prototypes véél beter werken dan de prototypes van de amerikanen , die de chip zelf maken.... Ze doen ook R&D en productontwikkeling voor Philips, Telenet en vele andere grote namen. In geen enkel van hun PIC's wordt de watchdogtimer gebruikt, en toch werken hun producen jarenlang vlekkeloos, en hebben ze hier nog nooit problemen mee gehad. Aldus hecht ik meer belang aan wat zij zeggen dan wat jij zegt..sorry daarvoor.

[Paul]

naftebakje schreef op donderdag 01 december 2005 @ 22:34:
sorry daarvoor.

Ach, mij maakt het niet uit hoor. Don't lose sleep over it

Dat het dat bedrijf lukt zonder watchdog is lovenswaardig, aan de andere kant is omzetten van 5 bitjes¹ en het af en toe aanroepen van de reset² nu niet zoveel moeite³ dat het het niet toevoegen van die extra zekerheid op het blijven draaien van je pic op machoisme duidt

1: enable en de interval
2: bijvoorbeeld bovenaan je main-loop
3: of met zulf een grote impact op de prestaties

Je zou nog aan kunnen voeren dat je door die auto-reset je eigen bugs niet meer kunt spotten (want je ziet niet dat het vastloopt) kun je na een reset (normaal 'aanzetten' == PowerOnReset) kijken waarom er gereset is, en bij een WDT-reset een getalletje in EEPROM verhogen of zo

[Lima]

héhé lang geleden dat ik nog eens tijd heb gehad om me ff bezig te houden met je code naftebakje.
Dus je laat die timer0 gewoon aftellen en dus elke keer dat hij je programma heeft doorgelopen in je ISR lijnen begint hij dus opnieuw.
Dus hij doorloopt je pwm bijvoorbeeld blauw laat hij 100 keer branden en daarna bijvoorbeeld rood 150 keer, hierna is hij klaar en wilt hij uit zijn ISR gaan maar je laat hem opnieuw beginnen met hetzelfde, dus dezelfde teller standen.
Pas als je op een knop duwt veroorzaakt hij een interrupt waardoor hij op andere lijnen springt en dus je teller van blauw of iets anders bijwerkt (verhoogd/verlaagt).

Maar ik zie gelijk in je ISR lijnen nergens staan dat je de teller waarde beinvloed naargelang welke knop is ingeduwt. En als je dit in je main programma zou doen zou hij je knoppen nooit uitlezen want normaal gezien blijft hij in je ISR lijnen gaan door die automatische interrupt.

Dus kort gezegd snap ik niet als je hem telkens automatisch laat inerrupten, hij je knoppen uitleest en waar hij die waarden aanpast.

[Lima]

@ naftebakje:

ik snap het nu wel je hebt gwn 39 instucties in je main programma, en daarna laat je hem interrupten.

Je bent dus maar beperkt tot 39 instucties tenzij je de klokfreq verhoogd en dan jezelfde 100hz behoud. Maar toch vind ik dan dat je maar bepekrt bent in uitbreidmogelijkheden.

[M14]

Ik programmeer voor school nu redelijk vaak met een Siemens uC. Nu wil ik voor wat hoby-projecten wat PIC's proggen. Alleen heb ik geen zin om over te schakelen op assambler, omdat ik nou eenmaal makkelijk in C programmeer. Maar met welke software kan ik C source compilen voor bijv. een pic16F88 / pic16f788 / pic16f84 / en noem maar op. En wat heb ik nodig om deze uC's te programmeren?

[naftebakje]

L i m a schreef op maandag 05 december 2005 @ 17:46:
@ naftebakje:

ik snap het nu wel je hebt gwn 39 instucties in je main programma, en daarna laat je hem interrupten.

Je bent dus maar beperkt tot 39 instucties tenzij je de klokfreq verhoogd en dan jezelfde 100hz behoud. Maar toch vind ik dan dat je maar bepekrt bent in uitbreidmogelijkheden.

Lees nog eens de uitleg die ik hier een stukje boven heb gegeven (met die 4 puntjes). De interrupt komt tussen het gewone main-programma in. Wanneer er een interrupt is, wordt eerst de interruptroutine doorlopen, daarna wordt er teruggekeerd naar de plaats in het main-programma waar je gebleven was. Je main-programma mag dus in principe oneindig veel instructies hebben, het zal alleen regelmatig (elke 39 instructies) even onderbroken worden om de interrupt tussenin even te doen.

Je kan alle code die je wil gewoon in de main-lus zetten, zolang je maar geen interrupts gebruikt, en timer0 niet gebruikt. Kijk bijvoorbeeld eens naar die code op het einde van de post die ik in deze post al heb aangehaald (ja, die met de 4 puntjes), dit is een voorbeeld van een main-programma. (de CALL-instructie die ik gebruik is ook interessant om even te bekijken, daardoor verspring je in het programma, met de mogelijkheid om terug te keren, met RETURN. Je moet er wel op letten dat elke CALL ook beeindigd wordt met een RETURN, of hij loopt vast. Je kan zo 8 calls na elkaar doen, en 8 returns, daardoor kom je terug naar 1 regel onder de 1e call, alsof er niets gebeurd is).

@M14: Ik weet niet hoe je met C kan werken op een PIC, maar aangezien in de FP al staat dat dit geprogged is met JAL, moet dit met JAL wel lukken denk ik. Ook zijn de fora op www.microchip.com (fabrikant van PIC's) heel interessant, als je gemakkelijk zelf te zoeken informatie over PIC's zoekt.
Programmeren kan met toestellen van Microchip zelf (ik heb ze op GOT al aangehaald denk ik, ff zoeken), of met een kitje van velleman (40€, gemakkelijk om te developpen, bevat ledjes en knopjes), of door zelf een programmer te maken, schema's vind je overal op internet, op http://www.circuitsonline.net/ bijvoorbeeld.
en nog @M14, het kan handig zijn om zelf wat te zoeken, en de thread te lezen voor je iets vraagt. Als je even kijkt, zie je in deze thread nog een gratis C-compiler voor PIC's vermeld staan, maar die mag je zelf zoeken, ik ga niet alles doen.

[ Voor 16% gewijzigd door naftebakje op 05-12-2005 20:00 ]

[Lima]

naftebakje,

die call instrcutie kende ik wel al dat was geen rpobleem, ik was ff vergeten dat je na je interrupt gwn weer verder gaat
Nu is dit idd wel ene interessante programma structuur, veeel beter al de mijne. En waarschijnlijk veel eenvoudiger. Maar het probleem is en blijft de knopjes, ook al krijg ik die goed geprogrammeerd, ik dnek dat het moeilijk zal zijn om bv 6knopje uit te lezen die niet ontdender zijn.
Ook het automatisch faden van de kleuren zal nie zo eenvoudig te programeren zijn denk ik.
Maar wel nice gedaan.

[naftebakje]

L i m a schreef op dinsdag 06 december 2005 @ 20:08:
...Maar het probleem is en blijft de knopjes, ook al krijg ik die goed geprogrammeerd, ik dnek dat het moeilijk zal zijn om bv 6knopje uit te lezen die niet ontdender zijn.

Kijk eens naar het voorbeeld dat ik heb gegeven van een mogelijke mainlus. Daarin werk ik met 4 knopjes, het ontdenderen doe ik door meteen ook een serieuze vertraging te maken, nadat de PIC 200 keer heeft gezien dat er op een knop wordt gedrukt, dan pas onderneemt hij actie. Dat is zelfs nog te snel, je kan em niet netjes regelen, maar foert. Het concept is waarschijnlijk duidelijk, een mens kan niet elke µs op een knopje drukken, dus moet het knopje enorm vertraagd worden, en dat introduceert meteen een goeie ontdendering.

Ook het automatisch faden van de kleuren zal nie zo eenvoudig te programeren zijn denk ik.

Dat is iets wat best aan de tijd gerelateerd wordt, maak een extra variabele, en laat die in de PWM_KLAAR (dus aan 100Hz ongeveer) eentje verhogen. Eenmaal een bepaalde waarde bereikt (vb 100 , dan ga je elke seconde je fading aanpassen) laat je hem jumpen naar een fade-module. Daar vergelijk je bijvoorbeeld de "naar daar toe faden" waarde met de gewenste waarde, en breng je degewenste waarde 1 stapje dichter bij de "naar daar toe faden" waarde.

Maar wel nice gedaan.

Tsja, je moet wat doen met je tijd.

[Lima]

Ja dat faden kan je zo oplossen maar om dan de snelheid aan te kunnen passen met twee drukknoppen zal wel wat moeilijker zijn vrees ik.
Je kunt misschien wel ervoor zorgen dat hij nog een andere prog heeft waar hij bij de call instructie elke keer de teller met wat meer waardes laat verhogen, maar hoe meer fade frequenties je dan wilt hoe meer programma's en hoe meer knoppen. Ook kan je de stappen dan zien.

Verzin daar maar eens iets op

(wss vind je het wel maar ik jammer genoeg niet )

[naftebakje]

L i m a schreef op donderdag 08 december 2005 @ 15:48:
Ja dat faden kan je zo oplossen maar om dan de snelheid aan te kunnen passen met twee drukknoppen zal wel wat moeilijker zijn vrees ik.
Je kunt misschien wel ervoor zorgen dat hij nog een andere prog heeft waar hij bij de call instructie elke keer de teller met wat meer waardes laat verhogen, maar hoe meer fade frequenties je dan wilt hoe meer programma's en hoe meer knoppen. Ook kan je de stappen dan zien.

Verzin daar maar eens iets op

(wss vind je het wel maar ik jammer genoeg niet )

Ik ben niet echt mee met wat je bedoeld, maar je kan bijvoorbeeld na 10 keer de interrupt routine te doen, naar je fading prog gaan. Je moet dan zorgen dat in je fading prog de benodigde aanpassingen gebeuren, vb rood +2, blauw -1, groen =. Als je 10 als basisgetal neemt, ben je in 255/(100/10)= 25.5 seconden (255 stappen PWM, 100Mz PWM, 10 is basisgetal dus na 10 keer PWM) van maximum naar minimum helderheid gaan, lijkt me niet dat je dan nog de stappen ziet. Die 25.5 sec is voor als je met 1tje verzet, wanneer je bijvoorbeeld per 10 verspringt, ben je in 2.55 sec van max naar min. Lijkt me regelbaar genoeg, sneller of trager lijkt me niet nodig, en trager is natuurlijk erg gemakkelijk te doen (basigetal vergroten...).