Hey,

Ik heb een vraagstukje, ik wil door middel van een interrupt de rest van het programma beinvloeden. Ik programmeer in C.
Het project is een 2tal rgb leds, met verschillende kleuren programma's daarin. Er zijn 3 schakelaars waarmee je de programma's kan kiezen.

Ik heb een timer lopen, met daarop een timer interrupt, dus periodiek wordt de interrupt-subroutine aangesproken. In de interrupt wordt een pwm functie aangeroepen, zodat 1000-2000x p/s de ledjes knipperen in de goede kleur.

Nu wil ik dat de PIC bijhoud of de schakelaars veranderen, en als dat zo is dat het huidige programma direct stopt, en hij verder gaat met het gekozen programma.

Ik had het idee, om tijdens de timer interrupt ook te checken of PORTA(van de schakelaars) zijn veranderd. Daar is op zich geen kunst aan, maar nu moet het huidige programma, waar die mee verder zou gaan al is de interrupt afgelopen, gestopt worden. En ik heb geen idee hoe dat zou moeten.

Kan iemand hier mij mee helpen?

Alvast bedankt... Alexander

Ik had het idee, om tijdens de timer interrupt ook te checken of PORTA(van de schakelaars) zijn veranderd.

Persoonlijk zou ik t andersom doen. Een "main" routine die je schakelaars checked, vervolgens aan de hand daarvan een (evt. Global) variabele zetten die t programma aangeeft, dan vervolgens in de interrupt routine aan de hand van de variabele het juiste pwm programma laten lopen.

Nja, met de manier waarop ik mijn programma heb geschreven, gaat dat niet gemakkelijk. In de main routine, worden er global variabelen veranderd, de pwm waardes, en die pwm waardes worden dan weer gelezen door de routine aangeroepen door de interrupt functie.

maar wat ik dus begrijp, is er geen mogelijkheid om het register te veranderen, waar de plaats in de main routine is,

want nadat de interrupt functie is afgelopen, gaat het programma daarna verder waar het gebleven was, dit wil ik tegengaan.

In de main routine, worden er global variabelen veranderd, de pwm waardes, en die pwm waardes worden dan weer gelezen door de routine aangeroepen door de interrupt functie.

Ehh.. dat is precies wat ik bedoelde . Je schakelaars uitlezen en dan deze waarden aanpassen.

want nadat de interrupt functie is afgelopen, gaat het programma daarna verder waar het gebleven was, dit wil ik tegengaan.

Ben bang dat je het fenomeen "Interrupt routine" niet helemaal begrijpt dan. Waarom zou je ueberhaupt een INT routine willen aanroepen die vervolgens niet meer mag terugkeren ?.

Je kunt ook een 2e (timer) interrupt routine maken die je schakelaars uitleest en de globals aanpast.

Ik zal een voorbeeld schetsen.
Ik heb een lichtprogramma, dat met een bepaalde schakelaarstand aangeroepen wordt.
Dat lichtprogramma houdt in dat langs elke kleur wordt gefade, en het duurt ongeveer 20 seconden. In de main routine worden de pwm variabelen veranderd, met een delay ertussen, zodat het niet te snel gaat.
Die pwm variabelen worden dan periodiek uitgelezen door de interrupt routine.

Nu wil ik dat het lichtprogramma wordt afgekapt als de schakelaars worden veranderd(dat was duidelijk dacht ik :P)

Ik wil dus in de interrupt routine een check inbouwen die periodiek kijkt of de schakelaars zijn veranderd, als dat niet zo is. dan mag het programma verder gaan waar het gebleven is. als de schakelaars wel zijn veranderd, moet het programma niet verder gaan waar het gebleven is, maar dan moet het in de main routine verder gaan op de plek waar de lichtprogramma's worden gekozen.

ik hoop dat het zo duidelijkis

Misschien ben ik eigenwijs maar waarom niet zo :


Oneindige Loop Begin

Lees schakelaars

Zet PWM variabelen aan de hand van gekozen programma.

Oneindige Loop einde

Interrupt routine
Lees PWM variabelen en zet kleur/fade
Return.

De delay in de main routine kan nog steeds maar wil niet zeggen dat je gedurende die 20 seconden nutteloos cpu cycles moet "verstoken" je kunt in die tijd ook andere dingen doen.

Dat is ook precies zo als ik mijn programma heb opgesteld.
De delays zijn nodig, om het veranderen van de pwm variabelen niet te snel te laten verlopen.

maar het probleem is, dat ik wil dat het kleurprogramma, die de pwm waardes veranderen. onderbroken wordt als er een verandering optreed bij de schakelaars.

Een flag bit gebruiken voor status en deze zetten naar wens (afhankelijk van de schakelaars) in de irq routine, en deze in main weer uitlezen...

Dat werkt ongeveer hetzelfde als een check inbouwen in de main routine. Maar mijn kleuren programma ziet er bijvoorbeeld als volgt uit:

C:


void rainbow()
{
     int i;
     
     for (i=0; i<255; i++) 
     {
         lr1=i;     lg1=0;     lb1=0;     
         lr2=i;     lg2=0;     lb2=0;                                   
         Delay_us(1000);
     }
     for (i=0; i<255; i++) 
     {
         lr1=255;   lg1=i;     lb1=0;     
         lr2=255;   lg2=i;     lb2=0;     
         Delay_us(1000);
     }
     for (i=0; i<255; i++) 
     {
         lr1=255-i; lg1=255;   lb1=0;     
         lr2=255-i; lg2=255;   lb2=0;     
         Delay_us(1000);
     }
     for (i=0; i<255; i++) 
     {
         lr1=0;     lg1=255;   lb1=i;     
         lr2=0;     lg2=255;   lb2=i;     
         Delay_us(1000);
     }
     for (i=0; i<255; i++) 
     {
         lr1=0;     lg1=255-i; lb1=255;   
         lr2=0;     lg2=255-i; lb2=255;   
         Delay_us(1000);
     }
     for (i=0; i<255; i++) 
     {
         lr1=0;     lg1=0;     lb1=255-i; 
         lr2=0;     lg2=0;     lb2=255-i; 
         Delay_us(1000);
     }
}

ik vind het lelijk om het tussen elke for lus te doen, en het is ook niet mooi om het in de for lus te doen.

Ik had gehoopt dat iemand wist hoe je dit mooi op kan lossen. Maarja, ik ga zelf nog wel even op zoek, vandaag niet zoveel tijd gehad. maar morgen ga ik ffies kijken.

Bedankt voor de reacties

Is "Rainbow" 1 kleurprogramma ?.

Ik had gehoopt dat iemand wist hoe je dit mooi op kan lossen.

Heb wel een paar suggesties.

Allereerst zou ik die waarden lr1, lg1 etc. in een array/tabel plaatsen.

Verder zou ik geen cycles verstoken met de Delay() routine maar een teller gebruiken.
Bijvoorbeeld de interrupt routine kan de teller ophogen en zolang ie kleiner is dan X uitvoeren, anders omschakelen naar de 2e waarde (dit kan evt ook in de main) en zo voort..

Als je telt in plaats van de Delay() kun je tussendoor ook nog controleren op je schakelaars en eventueel uit deze Rainbow routine springen als je schakelaars veranderen en naar het andere sub-programma springen.

Zo maar wat losse ideeen.

Is "Rainbow" 1 kleurprogramma ?.

Ja

Allereerst zou ik die waarden lr1, lg1 etc. in een array/tabel plaatsen.

Daar had ik ook al aan gedacht, maar het is volgens mij niet mogelijk om in een keer alle waardes in een array te plaatsen toch? of heb ik dat fout
array[] = {1,2,1,2,3}
dit werkt toch alleen als de array geinitialisserd word?

Verder zou ik geen cycles verstoken met de Delay() routine maar een teller gebruiken.
Bijvoorbeeld de interrupt routine kan de teller ophogen en zolang ie kleiner is dan X uitvoeren, anders omschakelen naar de 2e waarde (dit kan evt ook in de main) en zo voort..

Ik heb die delays erin gezet omdat het snel en gemakkelijk een vertraging geeft, ik kan het er altijd nog uit halen.

Als je telt in plaats van de Delay() kun je tussendoor ook nog controleren op je schakelaars en eventueel uit deze Rainbow routine springen als je schakelaars veranderen en naar het andere sub-programma springen.

dus jij zegt ook gewoon dat er in elk programma tig checks ingebouwd moeten worden?

dus jij zegt ook gewoon dat er in elk programma tig checks ingebouwd moeten worden?

Ja en nee, die 6 loops achter elkaar zou ik vervangen door 1 loop die tussendoor aan de hand van een teller de variabelen uit een array haalt en wisselt (op 1/6 van de totale doorlooptijd). Als je dat teruggebracht hebt tot 1 loop hoef je in de loop ook maar 1 keer de schakelaars te testen (dus "tig checks" valt ook wel mee). Maar misschien hebben anderen andere/betere ideeen.

dit werkt toch alleen als de array geinitialisserd word?

Heb je gelijk in , had even over t hoofd gezien dat ze geen statische waarde hebben.

[Bericht gewijzigd door bprosman op (14%)]

Ik heb een oplossing gevonden.
Ik vind het een prachtige oplossing, anderen zullen het misschien een iets minder mooie oplossing vinden

De enige regel die nodig is is: PCL = 0;
Hiermee reset je de PIC eigenlijk softwarematig.