Wanneer interrupts?

Heb je zelf al eens gekeken wat een interrupt (het woord zegt alles eigenlijk al) is? Dan kom je vanzelf bij het punt waarom ze handig zijn voor sommige dingen.

Voor geen enkele van bovengenoemde routines heb je interrupts nodig, zelfs niet gewenst, omdat ze teveel tijd in beslag nemen.
Interrupts worden meestal gebruikt om iets in het oog te houden waar pollen(mode) niet snel genoeg werkt.

Tenzij je zelf de USART routines moet ontwerpen, maar microC heeft die ingebouwd.

MGP,

Dus ik kan gewoon de functies schrijven zonder interrupts maar zit met een vraagje:

Heb je soms een voorbeeldje dat ik via de USART de string "hello mate" kan zenden naar de hyperterminal?

Wil eerst eenvoudig beginnen want daarna moet ik een protocol maken en dat is andere koek

Aangezien ik geen interrupts nodig heb, mag ik nog steeds modulair programmeren, dus de implementaties in de bijhorende module en de definities en prototypes in header files?

Interrupt voor ADC conversion complete (waarde uitlezen en ergens wegschrijven, andere kanaal selecteren, nieuwe conversie starten)

Interrupts voor de UART; transmit complete, receive complete. Transmit complete: nieuw byte klaarzetten zolang er nog data te verzenden is. Receive complete: controleren of je een volledig pakket hebt, eventueel checksums e.d. controleren, iets doen met het ontvangen bericht.

SPI interrupt; interrupt voor UART.

Idle loop: eventueel ontvangen berichten verwerken en nieuwe berichten voorbereiden. Anders: duimen draaien / slapen.

Communiceren zonder interrupts is moeilijker, en kost veel meer rekentijd (als je gaat wachten op het verzenden van de data e.d.). Ik heb maar zelden code in mijn idle-loop staan, de meeste programma's die ik schrijf werken alles via interrupts af. Misschien het updaten van een LCD of zo, maar de communicatie daarmee loopt dan meestal wel weer via timer interrupts.

[Bericht gewijzigd door SparkyGSX op zondag 29 maart 2009 23:45:58 (25%)]

SparkyGSX

Bedankt voor je info maar ik raak er niet uit om dit in interrupts te gieten.

Kan je eens een voorbeeld geven in mijn situatie:

stap 1
======
Instellen van een frequentie (digitaal) via SPI protocol, µC is de master en DDS is de slave

stap 2
======
Inlezen van Vin en Vout en sturen naar de interne ADC

stap 3
======
Data versturen en lezen met de USART
SPI data ook via de USART sturen

Ik zou je erg dankbaar zijn als je zowat voorbeeldcode in mijn situatie post of een pseudocode

Ik heb nu enkel gewone functies geschreven

Wat ik nog niet aan toe ben hoe kan ik vanuit mijn hyperterùminal "hello" sturen en dan laten zien dat het is aangekomen met een led in de PIC?

Ik gebruik dus wel MikroC en de ingebouwde libraries

Met vriendelijke groet
Stef

Als je mij die voorbeeldcode post kan ik er ook van leren en zo in het vervolg beter en vlotter programmeren ben ook maar beginner, in theorie veel gezien en lab één proefje maar zoveel leer je dan ook niet vind ik

Ik heb al van alles geprobeerd en wil dat gerust neerpoten morgen ofzo zodat je mijn code kan verbeteren om te werken met interrupts

[Bericht gewijzigd door Henry S. op maandag 30 maart 2009 00:35:30 (18%)]

Stap 1 maak je gewoon een routine van, die je 1x aanroept bij het starten van je schakeling en als je de freq wilt veranderen.

Stap 2

Timer interrupts gebruiken om elke xx ms een meting te doen.

Stap 3

Na elke adc meting een flag bitje setten. In je mainloop kijk je dan naar dat bitje en als die geset is stuur je de data door.

De ontvangen data van de pc ook afhandelen in een interrupt.

Zo zou ik het ongeveer doen, maar het is zeker niet de enige manier om het te doen.

Ik gebruik zelf geen PICs, maar de AVR serie, en ik ken MicroC ook niet, dus werkende voorbeeldcode voor de PIC kan ik je niet geven.

Probeer eerst eens een simpele interrupt routine te maken; de externe interrupts zijn hiervoor erg eenvoudig. Een voorbeeld hiervoor kun je wel online vinden. Als dat werkt, en je begrijpt ook hoe het werkt, kun stukje bij beetje je bestaande code interrupt-driven maken.

Een interrupt is als een bel op een telefoon.

Om zelf te gaan bellen is de telefoonbel overbodig. Je weet tòch dat je gaat bellen.

Maar om een telefoontje te ontvangen is de bel wèl erg handig. Ten eerste zou je anders elke paar seconden moeten luisteren of er iemand is. En ten tweede: als je geen telefoon verwacht, zou helemaal niemand je kunnen bereiken.

Interrupts zijn dus handig voor dingen die van buiten worden aangevraagd en NU moeten gebeuren.

Maar je eigen software kan ook één van zijn eigen interrupts genereren. Je kunt dus van iets een interrupt maken, en die toch uit de hoofdlus aanroepen.

Het kan ook nog zijn dat je docent je vraagt een paar interrupts te maken, hoewel dat voor de werking eigenlijk niet nodig zou zijn, gewoon omdat je het dan leert te doen.

Hallo Frederic,

Waar zou ik dan ergens interrupts kunnen gebruiken in mijn toepassing?

Als de ADC klaar is met digitaliseren, zou hij een interrupt kunnen geven. Dan hoeft de software niet stil te staan tijdens de conversie.
Idem met verzenden van data. Gooi het in de buffer en handel de bitjes af iedere keer als de bittimer een interrupt geeft.
En, zoals gezegd, voor het leren omgaan met interrupts zijn interrupts ook erg nuttig.

Let wel, dit zijn algemene voorbeelden. van PICs weet ik NICs. Zie daarvoor de bovenstaande posters, die hebben er veel meer kijk op.

Heb je geen boek waarin dat allemaal eens uitgelegd staat?

Edit: Je hebt mail met wat info.

Ik vind ten eerste dat een docent die je vraagt een bepaalde techniek te gebruiken eerst maar eens moet uitleggen waarom je die techniek moet beheersen.
Dat is immers de taak van de docent.

De functie van interrups is het kunnen onderbreken van een lopend programma teneinde een kort lopend programma even voorrang te geven.

Voorbeeld, de klok in je PC
Om die bij te houden word regelmatig een interupt gegeven zodat het stukje programma dat de tijd bij houdt even bijgewerkt kan worden
(in dit geval betreft het tot op zekere hoogte ook nog een realtime programma)
Ander voorbeeld is het besturen van je disk.
Als je gegevens van je floppy disk leest (wat een floppy disk is google je maar ) dan wil je niet dat het ding meteen daarna stil valt, want het kan best zijn dat je er snel weer gebruik van maakt.
Middels een interupt timer kun je dan het stukje programma uitvoeren dat bijhoud hoe lang er geen toegang is geweest.

Ander voorbeeld zijn netwerk kaarten of een serieele poort (jouw geval)
Je wil niet continu bij houden of er toevalig data beschikbaar is, das veel te veel gedoe.
Je zorgt er gewoon voor dat als de seriele poort data leest deze naar afloop een IRQ geeft, waardoor de data snel uitgelezen word en in een buffer wordt geplempt.
Daarna gaat de controlle terug naar je lopende programma en kun je op je gemak als je zin en tijd hebt de ontvangen gegevens verwerken.

Zo te zien schrijf je je spul in C of iets wat daar op lijkt
zoek eerst maar eens uit welke functies daar eventueel beschikbaar voor zijn.

De meester op school had je dat allemaal eerst maar es moeten vertellen.
Maar nee... hij vindt natuurlijk dat CoolePascal een grote mond heeft.
Feit is dat CoolePascal het desgewenst wel kan uitleggen !

Hallo MGP

Kan je eens een werkend voorbeeld geven waar interrupts worden gebruikt bij het verzenden en ontvangen van een byte als bvb een timer is afgelopen:

Ik denk het zo te doen

void main()
{
// Init de interrupts
INCON.GIE = 1;

// wachten op interrupts
while(1);
}

void interrupt()
{
if(T0IF && TOIE)
{
// Verstuur een byte
// Dat is fout want die zou nooit interrupts terug
// opvangen
// TOIF = 1;
// Moet zijn T0IF = 0;
}

Maar hoe als ik een byte ontvang van mijn laptop dat
moet deze toch ook eens het hoofprogramma onderbreken
maar op welke manier doe je dat ?
}

Graag een startvoorbeeld hoe je dat doet

Groetjes
S