Maskinnära programmering 6B2266

Maskinnära programmering 6B2266
Häfte: Interna enheter.
Timers, CCP, Interrupt, AD-omvandlare.
Programexempel för 16F84/16F628/16F874.
• Anslutning av extern LCD-display
• Avläsning av rotationspulsgivare
• Interrupt, INT-interruptet, RB-interruptet
• Timer0, Timer1 och Timer2
• CCP-enheterna, Capture Compare (PWM)
• Ex. Tändpunktsförställning hos förbränningsmotor.
• CCP-Capture, frekvensmätning.
• PWM, Pulse Width Modulation, pulsbreddsmodulering
• PWM-lab, Varvtalsratt till LEGO-motorn, varvtal/riktningsratt till LEGOmotorn
• Programmering av TIMER2 som samplingsklocka
• PIC16F874 AD-omvandlare
© 2005 William Sandqvist

LCD-display 16×1 egentligen (2×8)×1
GTC-1601 TR6N0C ELFA 75-511-53
GTC-1601 ser ut som en enkelradig display med 16 tecken,
med består i själva verket av två rader om 8 tecken som placerats efter varandra.
Bekvämt om man ska skriva ut tabeller, men besvärligt om det gäller långa meningar.
( Se programexemplet ).
Detta är ett exempelprogram med ELFA’s billigaste LCD-display (c:a 100:-).
LCD-displayer finns av många olika typer. Kanske köper Du själv en för användning
till din programmeringsuppgift?
De flesta LCD-displayer använder samma styrkrets och därför kan nedanstående
programexempel användas som en utgångspunkt även för andra displayer.
Man måste emellertid vara beredd på att läsa ”manualen” för displayen, och att det
kan behövas göra en del anpassningar av programmet.
LCD-displayernas kontaktstandard
Pin nr. Namn Funktion Pin nr. Namn Funktion
1 V SS Gnd, jord 8 D1 (databit 1)
2 V DD +5V, matningsp. 9 D2 (databit 2)
3 V EE Kontrast 10 D3 (databit 3)
4 RS Char/!Command 11 D4 databit 4
5 RD/!WR Read/!Write 12 D5 databit 5
6 E Enable, clock 13 D6 databit 6
7 D0 (databit 0) 14 D7 databit 7
Att mata spädbarn ...
Att mata spädbarn går lättare när man ger smakbitar (nibble).
Eftersom två smakbitar blir till en munsbit (byte), kan barnet ändå
bli mätt till slut.
När det gäller små PIC-processorer har man ofta ont om pinnar, och man vill då
ogärna ansluta en LCD-display med många ledningar. Alla LCD-displayer har därför
en finess som gör att tecken och kommandon kan "matas in" med 2 st 4-bitarstal
(nibble) i följd, i stället för med ett 8-bitarstal (byte). I så fall räcker det med att man
ansluter 4 dataledningar och 2 styrledningar ( om man avstår från att kunna läsa i
LCD-kretsens register, med RD/!WR ).
Det kommando som "ställer in" om 8 eller 4 dataledningar ska användas måste ges
först. Detta kommando har naturligtvis valts så att 4 bitar räcker för att skilja det från
de övriga kommandona!
3

PIC-processorn har en instruktion för att byta plats på två nibble i en byte
SWAPF f, d. Kompilatorn Cc5x har en inbyggd funktion för samma sak
x = swap(x);. Instruktionen finns med för att underlätta hantering av 4-bitsdata.
I programexemplet nedan plockas i stället nibblen ut "bit för bit". Det går då åt lite
fler instruktioner än om man använder swap, men programmet blir enklare att
anpassa ifall man skulle behöva koppla displayen till andra av PIC-processorns
pinnar.
Koppla så här ...
Kopplingsdäcket med 16x1-display. Även seriekommunikationskretsen får plats. ( Den används inte av
exempelprogrammet).
OBS! Viktigt! Avstörningskondensatorn 470 µF ELFA 67-011-48.
( LCD-displayen drar nämligen en hel del ström … )
4

Testprogram lcd16x1 "Hello world! "
/* lcd16x1.c LCD-display 4 bit data (nibble) conn. to PIC 16F628 */
/* GTC-1601-TR6N0C 1 (2) line 2x8 example: "Hello wo" + "rld! "*/
/* ELFA 75-511-53 c:a 110:- */
/* Internal ic: KS0066U used pins: D4-D7, RS, EN, RD/!WR=0 */
/*
________ ________
| \/ | RD/!WR = 0
D6--|RA2 16F628 RA1|--D5 (only write, wait while busy)
D7--|RA3
RA0|--D4
|RA4 RA7/OSC1|
|RA5/MCLR RA6/OSC2|
+5V--|Vss
Vdd|--GND
|RB0/INT (RB7)/PGD|
|RB1/Rx (RB6)/PGC|
|RB2/Tx
RB5|--RS
EN--|RB3/CCP (RB4)/PGM|
|__________________|
*/
#include "16F628.h"
#pragma config |= 0x3ff0
// use internal 4MHz oscillator
/* I/O-pin definitions */
/* change if you need a pin for a different purpose */
#pragma bit RS @ PORTB.5
#pragma bit EN @ PORTB.3
#pragma bit D7 @ PORTA.3
#pragma bit D6 @ PORTA.2
#pragma bit D5 @ PORTA.1
#pragma bit D4 @ PORTA.0
#include "delays.c"
void delay( char ); // ms delay function from file delays.c
void lcd_init( void );
void lcd_putchar( char );
char text1( char );
char text2( char );
void main( void)
{
CM0=1; CM1=1; CM2=1; // no comparators on PORTA pins
/* I/O-pin direction in/out definitions, change if needed */
TRISB = 0b011.0.1.0.111; // output to RS and EN
TRISA = 0b1111.0000; // output to D4-D7
char i;
lcd_init();
RS = 1; // LCD in character-mode
// display the 8 char text1() sentence
for(i=0; i

* ****************** FUNCTIONS ****************************** */
char text1( char x) // this is the way to store a sentence
{ skip(x); /* internal function CC5x. */
#pragma return[] = "Hello wo" // 8 chars max!
}
char text2( char x) // this is the way to store a sentence
{ skip(x); /* internal function CC5x. */
#pragma return[] = "rld! " // 8 chars max!
}
void lcd_init( void ) // must be run once before using the display
{ delay(40); // give LCD time to settle
/* Function set */
RS = 0; // LCD in command-mode
// 0010.xxxx 4-bit mode
// 0010.xxxx 4-bit mode
lcd_putchar(0b0010.0010);
// 0010.xxxx 4-bit mode three times!
// The display is actual two lines after each other
// 1.0.xxxxxx two line.display off.xxxxxx
lcd_putchar(0b0010.1.0.00);
/* Display ON/OFF Control */
// 0000.xxxx
// 1.1.0.0.xxxx 1.display on.cursor off.blink off.xxxx
lcd_putchar(0b0000.1.1.0.0);
/* Display clear */
// 0000.xxxx
// 0001.xxxx
lcd_putchar(0b0000.0001);
/* Entry mode set */
// 0000.xxxx
// 01.1.0.xxxx 01.increment mode.shift off.xxxx
lcd_putchar(0b0000.01.1.0);
// initialization is done!
}
void lcd_putchar( char data )
{ // must set LCD-mode before calling this function!
// RS = 1 LCD in character-mode
// RS = 0 LCD in command-mode
// upper Nibble
D7 = data.7;
D6 = data.6;
D5 = data.5;
D4 = data.4;
EN = 0;
EN = 1;
delay(5);
// lower Nibble
D7 = data.3;
D6 = data.2;
D5 = data.1;
D4 = data.0;
EN = 0;
EN = 1;
delay(5);
}
6

Lösta programexempel med PIC16F628
Avläsning av pulsgivare
Pulsgivare ELFA 35-847-60
Rotations-Pulsgivare har länge använts som digitala vinkelgivare i industrin, och de
används numera även som inställningsrattar och vred i hemelektronik ( tex. för Jog
up/down ).
De senare typerna har mekaniska kontakter och masstillverkas till låga priser ( det
finns pulsgivare från c:a 20:- ), så det finns all anledning att bekanta sig med
givartypen.
Givaren består av släpkontakter och en kodskiva. Den har tre anslutningar A B och C
(Common). Vid vridning blir det kontakt mellan A-C, eller B-C, eller med både A-C
B-C. Givaren spänningssätts genom att C-kontakten ansluts till jord och A och B -
kontakterna via var sin "pullup"-resistor ( tex 10 kΩ ) till matningsspänningen 5 V.
Utsignalen från givaren är en tvåbitars Gray-kod som för varja "klick" följer en
sekvens bestående av fyra steg.
ClockWise rotation ->
00 01 11 10 00

Det finns flera sätt att avläsa pulsgivaren på. Antingen avsöker man givaren så ofta att
man inte riskerar att missa någon tillståndsändring, eller så låter man alla
tillståndsförändringar generera avbrott, och låter avbrottsrutinen avläsa givaren.
PIC-processorer har en speciell finess. Man kan programera dem att generera avbrott
vid varje förändring på någon av fyra fyra portpinnar RB4 ... RB7. Denna finess
används bland annat till datormöss, som ju har två pulsgivare ( för x-led och y-led )
och därmed fyra signaler.
(Observera! man bör undvika att använda PORTB till något annat om man utnyttjar
denna finess).
Vid avläsningen av givaren ser man till att lagra det föregående tillståndet för att
kunna jämföra detta med det nuvarande tillståndet.
Varje pil i tillståndsdiagrammet består av ett sådant tillståndspar old.new.
Ett enkelt sätt att avläsa givaren är att räkna upp positionen vid pilen 00.01 och ned
positionen vid pilen 01.00. Även om kontakten studsar blir "nettoresultatet" det
rätta, eftersom man ju alltid måste gå den ena vägen en gång mer än den andra för att
byta tillstånd.
Enkoderavläsningsprogram
quad_A och quad_B är bitvariabler för de portpinnar A och B signalen anslutits till.
Det avlästa tillståndet och föregående tillstånd samlas i fyra bitar i variabeln trans
( transition, övergång ). Här får man god användning för att kompilatorn Cc5x har
bitoperationer ( som tillägg till ANSI-C ). Cc5x har även binära konstanter och
eftersom det är tillåtet att att avgränsa grupper av bitar med punkt-tecken så blir det
enkelt och tydligt att ange vilkor för de olika pilarna ( transitions ) i
tillståndsdiagrammet, tex. som if( trans == 0b00.01 ).
8

while(1)
{
/* read encoder new value */
trans.0 = quad_A;
trans.1 = quad_B;
}
/* compare with old value */
if( trans == 0b00.01 ) counter ++;
if( trans == 0b01.00 ) counter --;
delay(10);
/* replace old value with new value */
trans.2 = trans.0;
trans.3 = trans.1;
Enkoderavläsning. Testprogrammet quad62x.c
Inkoppling av pulsgivarkontakterna
När man kopplar in kontakter till portpinnar behöver man i allmänhet sk. "pullup"-
motstånd. En sluten kontakt kan ge "0"-nivån, men när kontakten är öppen blir nivån
obestämd utan pullup. PIC-processorerna har inbyggda "pullup"-motstånd ( c:a 10k )
som kopplas in med kommandot:
OPTION.7 = 0; /* internal pullup resistors is on */.
I figuren finns också två 1k serie-resistorer för att "isolera" pulsgivaren från
kretsprogrammeraren. Vid kretsprogrammering används ju pinnarna RB6 och RB7
( om vi inte hade haft behov av att omprogrammera PIC-kretsen hade dessa pinnar
varit helt lediga och serieresistorerna onödiga ).
I det följande programmet quad62x.c läses pulsgivaren av med hjälp av PCprogrammet
Hyperterminalen.
Därför tas funktionsfiler som innehåller initserial, putchar, string_out, inttoa och
delay med i arbetsbiblioteket.
9

* quad62x.c read rotary encoder with PC-terminal program */
/* SERIAL COMMUNICATION (RS232) 9600 baud. */
#include "16f628.h"
#include "Math16.h"
#pragma config |= 0x3ff0
char s[11]; /* global string buffer */
/* function prototypes */
void initserial( void ); /* in seriF62x.c */
bit putchar( char ); /* in seriF62x.c */
void string_out( void ); /* in stringIO.c */
void inttoa( int ); /* in ascnum.c */
void delay( char ); /* in delays.c */
#pragma bit quad_A @ PORTB.6
#pragma bit quad_B @ PORTB.7
#include "seriF62x.c"
#include "stringIO.c"
#include "ascnum.c"
#include "delays.c"
void main(void)
{
TRISB.6 = 1; /* quad_A is input */
TRISB.7 = 1; /* quad_B is input */
char trans; /* to store transition */
trans = 0;
int counter;
counter = 0;
delay( 10 );
initserial(); /* Initialise serial port */
putchar('\r');
putchar('\n');
while(1)
{
/* read encoder new value */
trans.0 = quad_A;
trans.1 = quad_B;
/* compare with old value */
if( trans == 0b00.01 ) counter ++;
if( trans == 0b01.00 ) counter --;
/* this is the delay between encoder readings */
inttoa( counter );
string_out();
putchar('\r'); /* Write on the same line! */
}
}
/* replace old value with new value */
trans.2 = trans.0;
trans.3 = trans.1;
Ta med filerna: seriF62x.c, stringIO.c, ascnum.c, delays.c
10

Interrupt, avbrottsprogramering av PIC
midrangekretsarna (ex. med 16F87x)
Interuptlogiken för 16F87x med 15 interuptkällor.
Interruptlogiken för 16F62x med 10 interruptkällor.
Interrupt och Polling
Antag att Du sitter i en skön fåtölj och läser en bok. Plötsligt blir Du avbruten av att
telefonen ringer, Du markerar med en blyertspenna var i boken Du befann dig och
svarar.
Under samtalet ringer det på dörrklockan och Du ber den Du talar med i telefonen
med att dröja kvar medan Du går till dörren. När Du är färdig med ärendet vid dörren
återupptar Du telefonsamtalet. När Du efter ett tag har talat färdigt i telefonen och
avslutat telefonsamtalet kan Du återvända till fåtöljen och fortsätta med att läsa den
goda boken - vid blyertsmärket.
11

Denna scen avser att belysa hur ett huvudprogram ( Du läser en bok ) via en
händelse ( telefonen ringer ) som genererar ett interrupt ( avbrott ) blir avbrutet så att
ett annat program, avbrottsprogrammet, utför en lämplig avbrottsrutin ( Du talar i
telefon ).
Avbrottsprogrammet blir i sin tur avbrutet och får då i stället utföra en annan
avbrottsrutin ( att ta ärendet vid ytterdörren ).
Om interruptmöjligheten inte fanns, om telefonen saknade ringsignal och ytterdörren
saknade dörrklocka, skulle Du gång på gång "oroligt" behöva avbryta läsningen av
boken för att lyfta telefonluren och fråga "är det någon där?", "är det någon där?",
och att öppna ytterdörren för att se efter om någon står utanför och väntar?
Detta kallas för Polling, avsökning.
Det är lätt att inse att Interrupt många gånger är att föredra framför Polling. De allra
flesta mikrostyrkretsar har därför försetts med mer eller mindre utvecklade
mekanismer för interrupt.
Global och Local enable
Om Du vill läsa din bok i lugn och ro utan att bli avbruten kan Du sätta på dig
öronproppar. Telefonen eller dörrklockan kan då ringa hur mycket som helst utan att
bli "betjänade". Du har omöjliggjort interrupt, Disable interrupt. Tar Du bort
öronpropparna har Du åter möjliggjort interrupt, Enable interrupt. Detta kallas för
att på global nivå enable/disable interrupt, Global enable.
Du har även möjlighet att på lokal nivå enabla/disabla interrupt, Local enable. Till
exempel kan Du på lokal nivå disabla telefonen genom att dra ur telefonjacket. Då
kommer Du fortfarande att kunna höra dörrklockan.
( detta målande exempel har jag lånat av en kollega, Robert Meyer )
PIC-processorernas interruptmekanismer
Interruptkällor, globalt, regionalt(?) och lokalt enable
PIC16F87x processorerna har upp till 15 olika interruptkällor. PIC16F628 har tio. De
enablas lokalt med "flaggor" som finns i registren INTCON, PIR1 och PIR2.
Eftersom de alla finns definierade som bitvariabler i respektive processors includefil
så behöver man inte hålla reda på i vilket register och i vilken bitposition de olika
flaggorna finns.
Den lokala enablebiten heter som källan, men med tillägg av bokstaven E på slutet
( tex. external interrupt INT har enableflaggan INTE ).
Interrupt enablas globalt med flaggan GIE ( Global interrupt enable ) som finns i
registret INTCON. Vid start har processorn interrupt disablat.
I INTCON finns även en flagga PEIE ( Peripheral interrupt enable ) som enablar
registren PIE1 och PIE2. Man kanske kan kalla detta för "regionalt enable"?
Observera således att tex CCP1E ( i PIE1 ) sammanlagt enablas på tre ställen.
1) CCP1E=1;, 2) PEIE=1; och 3) GIE=1;.
12

Några interruptkällor
Namn Register Kommentar
INT INTCON External interrupt, RB0/INT-pinnen
TMR0 INTCON TMR0 Overflow interrupt
RBI INTCON interrupt on change PORTB RB.0...RB.3
ADI PIE1 AD-converter interrupt (PIC16F87x)
TXI PIE1 USART Transmitter interrupt
RCI PIE1 USART Reciever interrupt
CCP1I PIE1 CCP1 Capture/Match interrupt
CCP2I PIE2 CCP2 Capture/Match interrupt (PIC16F87x)
TMR2I PIE1 TMR2 PR2 Match interrupt
TMR1I PIE1 TMR1 Overflow interrupt
Interruptrutin
När en interruptkälla, som är enablad, begär interrupt så anropas interruptrutinen.
Denna har alltid en fast adress i programminnet ( 0x0004 ). För att vara säker på att
interruptrutinen får rätt adress skriver man den först, före main():
Med raden interrupt int_server( void ) ger vi interruptrutinen namnet
int_server och definierar den på samma sätt som en vanlig funktion.
#include "16F874.h"
// #include "16F628.h"
#include "int16Cxx.h"
#pragma origin 4
interrupt int_server( void )
{
int_save_registers
/* interrupt routine */
int_restore_registers
}
void main( void )
{
/* the main program */
/* local enable */
/* global enable */
/* something that causes the interrupt */
}
I interruptrutinen gäller automatiskt att fortsatta interrupt är disablade, GIE=0;. ( Om
man skriver GIE=1; inuti interruptrutinen, kan nya händelser även avbryta
interruptrutinen, så gör inte detta ).
Till skillnad mot en vanlig funktion så vet man aldrig var i huvudprogrammet man
befinner sig när interruptet sker och interruptrutinen anropas. Interruptet kanske sker
mitt i ett vilkorsuttryck. När huvudprogrammet sedan får tillbaka kontrollen från
interruptrutinen, och får chansen att utvärdera vilkorsuttrycket, så vill det till att
interuptrutinen inte har förändrat några flaggor eller register!
13

Det är därför viktigt att interruptrutinen börjar med att lagra undan innehållet W-
registret mfl. på säker plats innan rutinen utför något som kan påverka dessa. Det sker
här genom att man includerat filen #include "int16Cxx.h" och skrivit
int_save_registers.
Denna textsträng är ett uttryck som C:s preprocessor "byter ut" mot några, för
processortypen, lämpliga instruktioner. Det är därför viktigt att man anger
processortypen med #include "16F874.h" (#include "16F628.h")
i början av programmet.
Genom att avsluta interruptrutinen med textsträngen
int_restore_registers
så läggs de ursprungliga registerinnehållen tillbaka innan återhoppet till
huvudprogrammet sker.
Väl tillbaka i huvudprogrammet blir interrupt åter enablat.
Interrupt flag bits
Registren INTCON, PIR1 och PIR2 innehåller olika interruptflagbits. Bitarna heter
som källan, men med tillägg av bokstaven F på slutet. Om en interruptflagbit är "1",
så innebär det att motsvarande händelse har inträffat.
Det är lämpligt att börja interruptrutinen med att undersöka vilken händelse det är
som utlöst interruptet, för att sedan styra programflödet till rätt åtgärd. Observera att
man måste 0-ställa aktuell interruptflagbit innan man lämnar interruptrutinen.
Annars kommer man direkt tillbaka till interruptrutinen! ( dvs. programmet låser sig ).
Även när man inte använder interrupt, när interruptet är disablat, kan programmet
ändå avkänna dessa bitar, dvs "polla" bitarna.
Bild på ett "klaffskåp med blänkare", en elektromekanisk signalanordning som förekom i början av
1900 talet i paradvåningar. Från trycknappar i de olika rummen kunde man kalla på
serveringspersonalen eller hembiträdet. Ringklockan i klaffskåpet ringde och motsvarande "blänkare"
för respektive rum föll ned. När uppdraget utförts tryckte betjäningen på knappen under "blänkaren"
så att den återställdes. - Är det månne härifrån Microchip fått idén till sitt interrupt?
14

Lösta programexempel med PIC16F628
INT Interrupt, RB0/INT-pinnen
External interrupt, yttre interrupt på pinnen RB0/INT genereras av en positiv eller
negativ flank ( 0..1 / 1..0 ). Valet av flanktyp gör man med bit INTEDG i OPTIONregistret.
Positiv flank gäller om INTEDG=1; och negativ flank om INTEDG=0;.
Tänds lysdioden när man trycker på knappen så fungerar interruptet ...
( Finns det någon som idag vet vad ”Killroy was here” betyder? )
/* exint62x.c External interrupt turns on light */
#include "16F628.h"
#include "int16Cxx.h"
#pragma config |= 0x3ff0
#pragma origin 4
interrupt int_server( void )
{
int_save_registers
if( INTF == 1 ) /* test if it is the INT-interrupt? */
{ /* this time it's obvius that it is! */
PORTA.2 = 1; /* Lightdiode on to show "Killroy was here" */
INTF = 0; /* Reset INT-flag before leaving */
}
int_restore_registers
}
void main( void )
{
/* the main program */
CM0=1; CM1=1; CM2=1; /* no comparators at PORTA */
TRISB.0 = 1; /* RB0/INT is input */
TRISA.2 = 0; /* RA2 output to lightdiode */
PORTA.2 = 0;
INTEDG = 0; /* interrupt on negative going edge */
INTE = 1; /* local enable */
GIE = 1; /* global enable */
while( 1 ) nop();
}
15

Lösta programexempel med PIC16F628
RB-Interrupt. Interrupt on change RB7,
RB6, RB5, RB4 -pinnarna
Fyra av PORTB's pinnar har den speciella egenskapen att de kan generera interrupt så
fort någon förändring inträffar. Denna funktion är främst tänkt för avkodning av
tangentbord eller för avläsning av datormöss. Det passar också utmärkt för avkodning
av pulsgivare ( se avläsning av pulsgivare ). Man bör inte göra något annat med
PORTB om man valt denna funktion, därför har vi kopplat lysdioden till PORTA i
stället.
( Grundinställningen för PORTA's pinnar är som komparatoringångar. Detta kopplar
man bort med kommandot: CM0=1; CM1=1; CM2=1; ).
Inkoppling av pulsgivarkontakterna
När man kopplar in kontakter till portpinnar behöver man i allmänhet sk. "pullup"-
motstånd. En sluten kontakten kan ge "0"-nivån, men när kontakten är öppen blir
nivån obestämd utan pullup. PIC-processorerna har inbyggda "pullup"-motstånd som
kopplas in med kommandot
OPTION.7 = 0; /* internal pullup resistors is on */.
I figuren fins två 1k serie-resistorer som behövs för att "isolera" pulsgivaren från
kretsprogrammeraren. Vid kretsprogrammering används ju pinnarna RB6 och RB7
( om vi inte hade haft behov av att omprogrammera PIC-kretsen hade dessa pinnar
varit helt lediga och serieresistorerna onödiga ).
En lysdiod på portpinne RA2 ska lysa varje gång pulsgivaren står i 0-läget.
Programmet kan kontrolleras genom att man vrider pulsgivaren lika många steg
framåt som bakåt och ger akt på att lysdioden tänds i 0-läget. Eftersom programmet
utnyttjar "interrupt on change" är det inte troligt att processorn "tappar bort"
räkneläget hur snabbt man än roterar pulsgivaren! Pröva!
16

* rbint62x.c RB-int reads rotary switch */
#include "16F628.h"
#include "int16Cxx.h"
#pragma config |= 0x3ff0
int counter; /* global pulsecounter */
char trans; /* global for transitions */
#pragma bit lightdiode @ PORTA.2
#pragma bit quad_A @ PORTB.6
#pragma bit quad_B @ PORTB.7
#define ON 1
#define OFF 0
#pragma origin 4
interrupt int_server( void )
{
int_save_registers
if( RBIF == 1 ) /* is it the RB pin change-interrupt? */
{ /* this time it's obvius that it is! */
/* read encoder new value */
trans.0 = quad_A;
trans.1 = quad_B;
/* compare with old value */
if( trans == 0b00.01 ) counter ++;
if( trans == 0b01.00 ) counter --;
/* replace old value with new value */
trans.2 = trans.0;
trans.3 = trans.1;
RBIF = 0; /* Reset RB-change flag before leaving */
}
int_restore_registers
}
void main( void )
{
/* the main program */
CM0=1; CM1=1; CM2=1; /* no comparators on PORTA */
OPTION.7 = 0; /* internal pullup resistors on */
TRISA.2 = 0; /* PA2 is output to lightdiode */
PORTA.2 = 0;
TRISB = 0b11000000; /* only inputs quad_A and quad_B */
trans = 0;
counter = 0;
RBIE = 1; /* local enable */
GIE = 1; /* global enable */
}
while( 1 )
{
if ( counter == 0 ) lightdiode = ON;
else lightdiode = OFF;
}
17

Timers
Timer0
Timer0 är den timer som alla PIC-kretsar har. Det är en 8-bitarsräknare.
Den kan programmeras att räkna pulser från T0CKI-pinnen, eller de interna
klockpulserna f osc /4.
Den kan förses med en prescaler så att den räknar långsammare.
När Timer0 "räknar runt" sätts en flagga T0IF, den kan även programmeras att då
orsaka programavbrott ( de enklaste PIC-kretsarna saknar avbrottsmöjligheten ).
Register TMR0 kan läsas och skrivas från programmet. Timer0 programmeras med
OPTION-registret.
OPTION-registret
18

Timer1
Timer1 är en 16-bitarsräknare. Den kan antingen räkna pulser från T1CKI-pinnen,
räkna de interna klockpulserna f osc /4, eller räkna klockpulser från en egen
kristalloscillator T1OSC. Det sista alternativet gäller användning med lågfrekventa
klock-kristaller 32,7680 kHz som ger hög noggrannhet med låg strömförbrukning.
Den egna kristalloscillatorn kan synkroniseras med processorns klocka ( Synk ). Om
den inte synkroniseras ( Asynk ), så kan den fortsätta att gå även om processorn
försätts i lågeffektläge, s.k. SLEEP-mode.
En programmerbar prescaler ger tillsammans med räknarens 16 bitar Timer1 ett
omfattande arbetsområde. När Timer1 "räknar runt" sätts en flagga TMR1IF, den kan
även programmeras att då orsaka programavbrott.
Register TMR1H och TMR1L kan läsas eller skrivas, ett i taget, från programmet.
Detta kräver speciell teknik. Om Timer1 används i samverkan med CCP-enheterna får
man tillgång till extra register som underlättar läsning/skrivning.
Timer1 programmeras med T1CON.
Register T1CON Timer1 control register
b7 b6 b5 b4 b3 b2 b1 b0
- - T1CKPS1 T1CKPS0 T1OSCEN !T1SYNK TMR1CS TMR1ON
Timer1 input ClocK Prescale Select, T1CKPS: T1CKPS1 T1CKPS1
11 = 1/8, 10 = 1/4, 01 = 1/2, 00 = 1/1
Timer1 OSCillator Enable, T1OSCEN: T1OSCEN
1 = oscillator enable, 0 = oscillator shut-off
Timer1 external clock input SYNChronisation, T1SYNC: !T1SYNC
1 = no synchronisation, 0 = synchronisation
TiMeR1 Clock Source select bit, TMR1CS: TMR1CS
1 = External clock RC0/T1OSO/T1CKI, 0 = internal clock f osc /4
TiMeR1 On bit, TMR1ON: TMR1ON
1 = enables Timer1, 0 = stops Timer1
19

Timer2
Timer2 är 8-bitarsräknare som främst används tillsammans med CCP-enheterna för att
generera PWM-signaler. Om Timer2 inte behövs till PWM-generering kan den
användas som intern "klocka" som med jämna mellanrum sätter en flagga TMR2IF. I
samband med detta kan den programmeras att orsaka programavbrott. ( Observera att
Timer2:s utgång inte är ansluten till någon yttre pinne ).
Timer2 räknar tills den når det värde som står i periodregistret PR2 då den 0-ställs
och börjar om. Timer2 använder klockpulser från f osc /4, men eftersom den både har en
Prescaler och en Postscaler blir inställningsområdet stort ( lika stort som för Timer1
16-bitsräknaren ).
Timer2 ställs in med T2CON-registret. TMR2 kan läsas och skrivas från programmet.
Hela Timer2 kan stängas av om den inte används, så att man minskar
strömförbrukningen.
Register T2CON Timer2 control register
b7 b6 b5 b4 b3 b2 b1 b0
- TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0 TMR2ON T2CKPS1 T2CKPS0
Timer2 OUTput Postscale Select bits, TOUTPS:
TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0
0000 1/1 0100 1/5 1000 1/9 1100 1/13
0001 1/2 0101 1/6 1001 1/10 1101 1/14
0010 1/3 0110 1/7 1010 1/11 1110 1/15
0011 1/4 0111 1/8 1011 1/12 1111 1/16
Timer2 ON bit, TMR2ON: TMR2ON
1 = Timer2 on, 0 = Timer2 off
Timer2 ClocK Prescale Select bits, T2CKPS: T2CKPS1 T2CKPS0
00 = 1/1, 01 = 1/4, 1x = 1/16
20

Hur läser/skriver man till 16-bit
"free running" Timer1?
Timer1 är en 16-bitarsräknare. Den måste läsas av som två 8-bitarstal, de 8 mest
signifikanta bitarna TMR1H och de 8 minst signifikana bitarna TMR1L. Detta kan vara
ett problem eftersom Timern kan "slå runt" mellan avläsningarna av 8-bits talen.
Följande kod visar det säkra sättet
( men eventuellt interrupt måste vara avstängt under avläsningen):
long unsigned int time;
unsigned char TEMPH;
unsigned char TEMPL;
TEMPH = TMR1H;
TEMPL = TMR1L;
if (TEMPH == TMR1H) /* Timer1 has not rolled over = good value */
{
time = TEMPH*256;
time += TEMPL;
}
else /* Timer1 has rolled over - no new rollover for some time */
/* read a new good value */
{
time = TMR1H*256;
time += TMR1L;
}
Det kan också vara problematiskt att skriva till en 16-bitarsräknare eftersom det måste
ske som två 8-bitarstal. Detta är det säkra sättet (Interrupt måste vara avstängt under
skrivningen):
TMR1L = 0; /* clear low byte = no rollover for some time */
TMR1H = 12345/256; /* high byte of constant 12345 */
TMR1L = 12345%256; /* low byte of constant 12345 */
Observera att Timer1 ofta används tillsammans med en CCP-enhet. Vid Capture läses
Timer1 av på ett säkert sätt av hårdvaran och resultatet hamnar i registerparet CCPRH
och CCPRL.
long unsigned int time;
time = CCPR1H*256 + CCPR1L
21

CCP-enheterna,
Capture/Compare/(PWM)
PIC-processorena kan vara utrustade med en eller flera CCP-enheter
(Capture/Compare/PWM). Varje CCP innehåller ett 16-bitarsregister ( 2×8 bit,
CCPRH och CCPRL ) som kan användas som ett 16-bitars Capture-register, ett 16-
bitars Compare-register, eller som ett 10-bitars PWM Master/Slave DutyCycleregister.
CCP-enheten innehåller också en 16-bitars komparator. Varje CCP-enhet har
en portpinne, CCP-pinnen, för anslutning till omvärlden.
Man ställer in CCP-enheternas arbetssätt med CCPCON-register. Eftersom CCPenheterna
antingen samverkar med Timer1 eller Timer2 måste man även göra timerinställningar.
CCP-pinnen måste ställas in som ingång eller utgång med aktuellt TRIS-register.
PIC16F628 har en CCP-enhet CCP1 ( pinne 9, RB3/CCP1 TRISB.3 ). Register
CCP1CON, CCPR1H och CCPR1L.
Register CCP1CON
b7 b6 b5 b4 b3 b2 b1 b0
- - CCP1X CCP1Y CCP1M3 CCP1M2 CCP1M1 CCP1M0
CCP1X CCP1Y PWM Minst signifikanta bitar
22

CCP1M3 CCP1M2 CCP1M1 CCP1M0 CCP mode select bits
M3 M2
M3 M2
mode-Beskrivning
M1 M0
M1 M0
mode-Beskrivning
0000 Reset av CCP-modulen 1000 Compare, 1-ställ CCP-pinne, CCPIF-flagga
Capture, varje neg flank,
0100
CCPIF-flagga
1001 Compare, 0-ställ CCP-pinne, CCPIF-flagga
Capture, var pos flank, CCPIFflagga
0101
1010 Compare, CCPIF-flagga
Capture, var 4:e pos flank,
Compare, speciell händelse, CCPIF-flagga
0110
CCPIF-flagga
1011
CCP1: 0-ställ Timer1
Capture, var 16:e pos flank,
0111
CCPIF-flagga
11xx PWM-mode
CCPIF-flaggan ( CCP1IF ) kan användas till att orsaka avbrott, interrupt. Observera
att flaggorna måste 0-ställas av programmet, att de inte 0-ställs automatiskt när de
läses!
Capture mode
Capture innebär att Timer1:s ögonblicksvärde 16-bitar kopieras över till de två 8-
bitarsregistren CCPR1H och CCPR1L, när en förutbestämd "händelse" inträffar på
CCP1 - pinnen (pinne 9). De två 8-bitarstalen kan sammansättas till en 16-
bitarsvariabel:
unsigned long time;
time = CCPR1H*256 ;
time += CCPR1L ;
Vid Capture sätts CCP1IF -flaggan i PIR1 -registret. Det går att programmera så att
avbrott, Interrupt, utlöses av detta.
• Ställ in Timer1, internal/external, prescaler, synk/asynk, on/off.
• CCP1-mode.
• TRISB.3 = 1;
23

Compare mode
Compare innebär att ett 16-bitars tal i CCPR1 -registren kontinuerligt jämförs med
Timer1:s räknevärde. När överenstämmelse sker blir CCP1-pinnen
hög/låg/oförändrad beroende på inställningen i CCP1CON.
Överenstämmelsen kan programmeras att dessutom utlösa avbrott, interrupt.
Förutom påverkan på CCP-pinnen, finns det möjlighet att välja en så kallad "speciell
händelse" (special event). För CCP1 innebär denna 0-ställning av Timer1.
Ställ in Timer1, internal/external, prescaler, synk/asynk, on/off.
• CCP1-mode.
• TRISB.3 = 0;
Timer1, valbar period
CCP-enheten kan 0-ställa Timer1 med special event, vid det tal som står i
registerparet CCPR. Timer1:s periodtid förkortas (men inget avbrott sker
/* fosc = 4 MHz, Timer1Period = 0,001 s (1000 Hz) */
T1CON = 0b00.00.0.1.0.1;
/* --.presc=1/1.osc=shut off.no sync.internal clk.Enable timer */
/* CCPR = (fosc/4) * Timer1Period = 1000000*0,001 = 1000 */
/* CCPR = 1000 = 0x3E8 CCPR1H = 0x3, CCPR1L = 0xE8 */
CCPR1H = 0x3;
CCPR1L = 0xE8;
CCP1CON = 0b00.00.1011; /* --. 00. special event */
/* Timer1Period is now 1 ms */
24

Så här skulle PIC-kretsarnas CCP-enheter kunna
användas i en bilmotor … ( exempel med PIC16F87x )
Elektronisk styrning av
förbränningsmotorer
De flesta bilmotorer ( och många andra förbränningsmotorer ) är i dag elektroniskt
styrda. Detta har gjort underverk med bilarna, men samtidigt har verkstäderna förlorat
kontrollen över justeringen av dessa bilar, även märkesverkstäder kan ha problem
med att justera det enklaste tomgångsproblem.
Intresset för att lära sig hur motorstyrningarna egentligen fungerar är därför stort. På
IT-universitetets Mekatronik-inriktning har genom åren flera projekt handlat om detta.
Några teknologer har efter projekten kunnat söka sig till motorindustrin för liknande
arbetsupgifter.
De mikrostyrkretsar ( PIC16F87x ) som används i Mekatronik-inriktningens projekt
har sitt ursprung i kretsar för bilindustrin, och det kan därför vara intressant att se
hur de ingående enheterna kan användas för att lösa motorstyrningsuppgifter.
Behovet av tändförställning
När bränsle/luftblandningen antänds i kompressionskammaren, börjar
förbränningen vid tändstiftet och sprids därifrån vidare i
bränsle/luftblandningen. Det tar en given tid för hela blandningen att brinna,
expandera och därmed tvinga kolven ner i loppet. Det är därför man måste
börja tändningsprocessen ( Z ) innan kolven når övre dödläge (ÖD). Det är
detta som kallas för tändförställning.
Om motorns varvtal ökar så får blandningen kortare tid på sig att brinna.
Man behöver därför öka tändförställningen med ökat varvtal.
Nu är det så att den hastighet med vilken bränsle/luftblandningen brinner
varierar med hur full cylindern är vid kompressionen ( cylinderfyllning ).
Vid litet gaspådrag och höga varvtal fylls cylindern mindre än vid stort
"gaspådrag" och låga varvtal.
Det behövs således även olika tändförställningar vid samma varvtal
beroende på "gaspådrag" ( egentligen menar vi motorbelastning i stället för
"gaspådrag" ).
• Z = f ( varvtal, motorbelastning )
25

Givare för vinkel, varvtal, motorbelastning
Vinkelläge
Fordonsindustrin har hittat ett mycket billigt sätt
att mäta motoraxelns vinkelläge. En induktiv
givare avger pulser när motorns startkuggkrans
roterar, och en annan induktiv givare avger en
puls per varv då ett "indexstift" passerar. (
Tekniken beskrivs i boken Mätgivare ).
Antag att startkransen har 130 kuggar. För att
grovt hålla reda på vinkelläget "räknar" man i
princip de kuggar som passerar med en modulo-
130-räknare.
Mikrostyrkretsen PIC6F87x har tre interna räknare ( Timer0, Timer1 och Timer2).
Timer0 är lämplig till denna uppgift, det är en åttabitarsräknare, dvs en modulo-256-
räknare som "slår runt" vid talet 255 och då börjar om med talet 0. Timer0 kan
programmeras att räkna pulser som inkommer på pinne T0CKI. Kugg-givaren ansluts
till denna pinne.
Man kan få ett avbrott (interrupt) i programkörningen var gång Timer0 "slår runt".
Om man vid avbrotten passar på att direkt "ladda" Timer0 med talet 126
(256-130=126) blir räknecykeln förkortad till 130 steg, dvs vi får en
modulo-130-räknare. Aktuell kugge kan man få reda på genom att läsa av Timer0 och
dra ifrån talet 126.
Antag att indexstiftet är placerat vid kugge nr "0". Mikrostyrkretsen PIC6F87x har en
yttre avbrottsingång INT. Indexpinnens givare ansluts till denna. Vid start av motorn
"laddar" man Timer0 med talet 126 när index-pinnen passerar sin givare och
genererar avbrott. Från denna stund håller Timer0 "reda på" kuggarna.
26

Varvtal
Varvtalsmätningen går i princip till så att man mäter den tid det tar för kuggarna att
passera Kugg-givaren. Rotationen sker inte med konstant varvtal utan "ryckigt",
eftersom förbränningsmotorer är explosionsmotorer.
PIC-processorerna kan vara utrustade med en eller flera så kallade CCP-enheter
(CaptureComparePWM). För tidmätning låter man CCP-enheten vara inställd på
Capture, och använder Timer1. Timer1 är en 16-bitsräknare (2×8 bitar), den
programmeras att räkna i takt med processorns klocka. CCP-enhetens ingångspinne
ansluts till Kugg-givaren och programmeras att reagera på positiva pulsflanker. Vid
varje kugge kommer då automatiskt Timer1 att "läsas av" ( = capture) och resultatet
hamnar i CCP-enhetens register CCPRH och CCPRL. De två CCPR-registren kan
hanteras som ett 16-bitarstal. Vid "Capture" anropas avbrottsrutinen ( interrupt ) och i
denna kan tidsvärdet i CCPR-registren lagras undan. I princip beräknas tiden mellan
två kuggpassager som skillnaden mellan två tidsvärden, och varvtalet som det
inverterade värdet av denna tid.
Motorbelastning
Tryckgivare, varmtråds-massflödesmätare, trottelpotentiometer.
Motorns belastning kan mätas på många olika sätt. Den klassiska metoden för
förgasarmotorer är att mäta undertrycket i förgasaren med en tryckgivare. En annan
metod är att mäta luftflödet till motorn med en varmtråds-massflödesmätare. Ett
ungefärligt mått på motorns belastning kan man få genom att med en trottelpotentiometer
mäta vilket "gaspådrag" föraren ger.
( Givarna beskrivs i boken Mätgivare ).
27

Dessa givare har alla en analog spänning som utstorhet, och ansluts därför enklast till
PIC-processorernas inbyggda AD-omvandlare. ( PIC16F87x har AD-omvandlaren ).
Tändförställningstabell
Sambandet mellan tändpunktens förställning och varvtalet
tillsammans med belastningen är komplicerat och beskrivs bäst
som en "karta" ( mappad tändning ).
Rent experimentellt kan man placera fordonet på en så kallad
"rullande landsväg" och systematiskt ändra varvtal och
belastning och för varje kombination "pröva fram" den bästa
tändförställningen. Mätvärdena kan man samla i en
Tändförställningstabell.
Med Matlab kan man visualisera tändförställningstabellen.
3-D plot med Matlab. (Klipp ut texten och prova den i Matlabs kommandofönster).
Observera att tabellens värden är "fejkade" och är endast avsedda som principexempel.
ignadv = [ 30 40 40 40 20 15 15 15
20 40 40 40 25 20 20 20
40 60 60 50 30 20 20 15
40 70 70 60 40 25 25 20
45 80 85 80 50 40 30 25
50 85 85 70 60 50 35 30
60 90 90 80 75 60 40 35
70 95 95 80 75 65 50 40 ];
surf(ignadv);
28

Tabellfunktion i PIC-processorn.
Så här kan tabellen programmeras som en funktion i PIC-processorn. När funktionen
anropas med tex. ignitionmap(0,0) (rad 0 kolumn 0) returnerar den talet 30.
/* speed 3 bits 0...7 ; torque 3 bits 0...7 */
char ignitionmap(char speed, char torque)
{
char index;
index = speed*8 + torque; /* index for 64 table entries */
skip(index)
return 30;
return 40;
... /* the next 60 table entries */
...
return 50;
return 40;
}
Tändningen
Med hjälp av Timer0 vet man motorns vinkel. När man närmar sig tändpunkten mäter
man tiden mellan passagen av två kuggar med den första CCP-enhetens Capturefunktion,
och motorns belastning med hjälp av AD-omvandlaren. Genom att anropa
tabellfunktionen så får man veta vilken tändförställning som är den rätta.
För att utföra tändningen vid rätt tidpunkt låter man PIC-processorns andra CCPenhet
vara inställd på Compare.
När motorn nått den kugge som innehåller intervallet för tändningen, laddar man
CCP-registren med ett tal, en tidsfördröjning. En programmerbar "händelse" utförs
med CCP-pinnen då Timer1 når ( compare ) detta tal. Tändspolens drivkrets har
anslutits till CCP-pinnen på ett sådant sätt så att den programmerade "händelsen"
utlöser gnistan.
CCP-enheten är så konstruerad att "händelsen" åtföljs av att Timer1 0-ställs ( och i fallet med CCPenhet
2 att AD-omvandlaren startas ). Ett anrop till avbrottsrutinen ( interrupt ) kan ske nu om så
önskas.
29

Lösta programexempel med PIC16F628
Indirekt frekvensmätning, periodtid,
multiperiodtid
Frekvensmätning sker ofta indirekt som periodtidsmätning ( T ), varefter frekvensen
( f ) beräknas som f = 1/T. Periodtiden är tiden mellan två lika flanker hos
mätsignalen. Frekvensmätning kan ske inom ett brett intervall eftersom Timer1 har en
Prescaler och det dessutom är möjligt att programmera mätning av, varje eller var
fjärde eller var åttonde flank (multiperiodmätning).
Vi antar att f osc = 4 MHz, och att Timer1 räknar T1CK = f osc /4 = 1 MHz.
Timer1-ticket blir då 1 µs och Timer1-perioden 2 16 ×1µs = 66 ms ( 15,3 Hz ).
Om en 100 kHz-signal ( med periodtiden 10 µs ) inkommer på CCP-pinnen hinner det
gå 10 Timer1-tick mellan två positiva flanker. Om det i stället är en 10 kHz-signal går
det 100 Timer1-tick mellan två flanker, och vid en 1 kHz-signal blir det 1000
Timer1-tick. Vid 100 Hz blir det 10000 Timer1-tick.
Är frekvensen 10 Hz hinner Timer1 räkna mer än ett helt varv mellan två flanker.
Vid höga frekvenser som tex en 100 kHz-signalen kan man öka mätupplösningen
genom att bara registrera var åttonde flank ( det går då 80 Timer1-tick mellan de
registrerade flankerna). Vid låga frekvenser som 10 Hz-signalen måste man antingen
hålla räkning på hur många gånger Timer1 räknar runt, eller låta Timer1 räkna
långsammare genom att använda prescalern, tex. 1/8.
30

Programexempel frekvensmätning med 16F628
/* fmeas62x.c frequency measurement for 16F628 */
/* input frequency 100 Hz - 10 kHz at CCP1-pin */
#include "16f628.h"
#include "math16.h"
#pragma config |= 0x3ff1
/* function prototypes */
void unslongtoa( unsigned long ); /* in ascnum.c */
void initserial(); /* in seriF62x.c */
bit putchar( char ); /* in seriF62x.c */
void delay( char ); /* in delays.c */
void string_out( void ); /* in stringIO.c */
char text1( char ); /* function prototype */
char s[11]; /* Global char array for digits */
#include "seriF62x.c"
#include "ascnum.c"
#include "stringIO.c"
#include "delays.c"
void main(void)
{
char i;
uns16 T, f, t1, t2;
initserial();
TRISB.3 = 1; /* CCP1-pin is input */
/* Settings */
/* "--"."Prescale 1/1"."osc shut off"."synchr"."fosc/4"."on" */
T1CON = 0b00.00.0.0.0.1 ;
/* "--"."--"."Capture each pos edge" */
CCP1CON = 0b00.00.0101 ;
while(1)
{
CCP1IF = 0 ; /* reset flag */
while (CCP1IF == 0 ); /* wait for capture */
t1 = CCPR1H*256;
t1 += CCPR1L;
CCP1IF = 0 ; /* reset flag */
while (CCP1IF == 0 ); /* wait for next capture */
t2 = CCPR1H*256;
t2 += CCPR1L;
/* Calculations */
T = t2 - t1; /* calculate period */
f = 1000000/T; /* calculate frequency */
31

* print textstring text1 */
for(i = 0; putchar( text1(i)); i++) ;
/* print variable f */
unslongtoa(f);
string_out();
putchar('\r'); putchar('\n');
}
}
delay( 10 );
/* String to write */
char text1( char x)
{
skip(x);
#pragma return[] = "The frequency is [Hz]: " '\0'
}
Hjälpfunktioner finns i filerna seriF62x.c, ascnum.c,
stringIO.c, delays.c
Programmet utnyttjar funktioner som ligger i andra filer och som därför måste tas
med i arbetsbiblioteket.
SeriF62x.c ( funktionsprototyp seriF62x.h )
ascnum.c ( funktionsprototyp ascnum.h )
stringIO.c ( funktionsprototyp stringIO.h )
delays.c ( funktionsprototyp delays.h )
Förmodligen har Du ingen tongenerator hemma. Den som vill pröva
frekvesmätningsprogrammet kan koppla frekvensdelarkretsen 74HC4040’s
klockingång till PIC-processorns RA6/CLKOUT (1MHz). På 4040-kretsens ben
återfinner man 1 MHz neddelat steg för steg, dvs. frekvenserna 500 kHz, 250 kHz,
125kHz, … 244Hz. Vid labtillfället i skolan finns en tongenerator och FLUKE
scopemeter-123.
32

PWM, Pulse Width Modulation
Medan mikrostyrkretsar ofta har inbyggda AD-omvandlare, är det mer sällan som de
också har DA-omvandlare. Anledningen till detta är att det finns en genväg att digitalt
framställa analoga signaler - PWM, Pulse Width Modulation, pulsbreddsmodulering.
Pulsbreddsmodulerad spänning, många komponenter märker bara det analoga medelvärdet.
En pulsbreddsmodulerad signal består av en snabb följd av pulser. Många
komponenter är "tröga" och hinner inte uppfatta att signalen ändrar sig, utan reagerar
på signalens medelvärde som om det vore en konstant spänning (medelspänningen).
Det gäller tex motorer, glödlampor och värmeelement. Har man snabba komponenter
som skulle kunna upptäcka variationerna så filtrerar man PWM-signalen för att få ett
konstant värde.
PWM-signalen har fast frekvens och periodtid, medan pulstiden ( t 1 ) varieras på
pulsluckans ( t 0 ) bekostnad. Signalens DutyCycle = t 1 / ( t 1 + t 0 ) är direkt
proportionell mot det analoga medelvärdet.
Hur programmerar man en PWM-signal?
( ett avskräckande exempel utan PWM-enhet )
I detta exempel låter vi lysdioden styras med en PWM-signal så att den lyser med
75% intensitet ( medelvärde ) då strömställaren är "1" och med 25% intensitet då
strömställaren är "0".
33

Alla PIC-processorer har åtminstone en inbyggd räknare, Timer0. Timer0 är en 8-
bitsräknare, den räknar således hela tiden från 0 till 255 då den slår runt och börjar
från 0 igen. Med OPTION - registret väljer man räknehastigheten.
Med ett tal Duty mellan 0 och 255 styr man PWM-signalen. Så länge Timer0 räknar
under talet Duty låter man PWM-utgångspinnen vara "1", för att 0-ställa den så fort
Timer0 räknat förbi talet Duty.
Eftersom programmet hela tiden ( åtminstone varje Timer0-tick ) måste "läsa av"
Timer0 får man inte så mycket processortid över för annat med denna metod ( ju
högre PWM-frekvens, desto mindre tid till övriga uppgifter ).
Många PIC-processorer har inbyggda "PWM-enheter". De kan självständigt generera
PWM-signaler utan allt för stor inblandning från "huvudprogrammet".
PWM-signal med Timer0
/*
pwmpic.c Timer0-PWM-signal ( Bad example! )
===========================================
*/
#include "16F628.h"
#pragma config |= 0x3ff0
#define ON 1
#define OFF 0
#pragma bit PWM_out @ PORTB.0
#pragma bit Contact @ PORTB.1
char MoreToDo(void);
char Duty; /* global variable */
void main( void)
{
Duty = 0; /* start with zero DutyCycle */
TRISB = 0b11111110 ; /* PORTB.0 is output */
/* PORTB.1 is input */
OPTION = 0b11000111; /* Timer0 Prescaler divide by 256 */
while (1) /* forever */
{
char i;
if (TMR0 < Duty) PWM_out = 1;
else PWM_out = 0;
Duty = MoreToDo(); /* Be back in one TIMER0-tick ! */
}
}
34

* Function*/
char MoreToDo(void)
{
char Duty;
if( Contact == ON ) Duty = 191; /* 191/255 = 75% Dutycycle */
/* _______ __ */
/* _| |__| */
/* */
else Duty = 64; /* 64/255 = 25% Dutycycle */
/* __ __ */
/* _| |_______| */
/* */
return Duty; /* Be back in one TIMER0-tick! */
}
I exemplet ovan antar vi att PIC-processorn har klockfrekvensen 4 MHz och att
Timer0 använder prescalerns /256 och därför räknar med frekvensen ( f osc /4 )/256 =
10 6 /256 = 3906 Hz, tiden mellan två Timer0-tick blir 0,25 ms.
PWM-signalens periodtid blir (1/3906)×256 = 66 ms. PWM-signalens frekvens blir
därför låg, 15 Hz.
Denna signal duger till ett värmeelement, medan en glödlampa riskerar att "flimra"
störande.
Om Timer0 inte använder prescalern blir PWM-frekvensen 256 ggr högre dvs 3900
Hz, men då blir utrymmet för andra programaktiviteter än själva genereringen av
PWM-signalen obefintliga.
Ofta vill man ha PWM-frekvenser över 20000 Hz så att man undviker att vibrationer i
utrustningen blir "hörbara" (för människor).
Även om det går att programmera en PWM-signal direkt, så finns det således ett stort
behov av att i stället kunna använda inbyggda "PWM-enheter" som kan avlasta
processorn.
( Microchip visar i sin application note AN654 på bättre sätt att programmera PWM
med Timer0 genom att utnyttja avbrott då timern "slår runt" ).
35

PWM med CCP-enheter
( CaptureComparePWM )
CCP-enheterna kan användas till att generera PWM-signaler. Detta sker i samverkan
med Timer2.
Timer2 är en 8-bitars räknare, vid PWM kompletteras den internt i processorn med 2
bitar till en 10-bitarsräknare. Därigenom kan PWM-signaler med upp till 10 bitars
upplösning genereras. PWM-signalens periodtid kan ställas in med Timer2:s prescaler
( T2CON ) och med periodregistret PR2. Inställningen i periodregistret påverkar hur
långt Timer2 räknar, och därigenom även PWM-signalens upplösning. Högst
upplösning får man om Timer2 räknar fullt, dvs PR2 = 255, och periodtiden bara
justeras med prescalern T2CON.
(Timer2 som "10-bitarsräknare" räknar f osc inte f osc /4 ).
Timer2 har även en postscaler, men den används inte vid PWM. Eftersom denna kan
generera regelbundna avbrott kan man använda den till att uppdatera PWM-enhetens
DutyTime.
Från CCP-enheten används två 8 bitarsregister CCPRL och CCPRH och en 16-bitars
komparator ( bara 10 bitar används ). CCPRH programmeras inte av användaren utan
är bara en intern buffert vid PWM.
PWM-signalens DutyTime, T Duty , "beställs" som 8 mest signifikanta bitar med
registret CCPRL ( trots registrets namn! ) och 2 extra minst signifikanta bitar från
registret CCPCON bitarna CCPX och CCPY.
Om man har 10 bitars upplösning, men nöjer sig med 8 bitars upplösning, räcker det
att placera 8 bitar för önskad DutyTime, T Duty , i registret CCPRL, och man behöver i
så fall inte bry sig om de två extra bitarna i register CCPCON utan låter dem vara 0.
36

Funktion
• Timer2 räknar tills den når talet i periodregistret PR2, då 0-ställs timern och
samtidigt 1-ställs en SR-låskrets. Detta påbörjar PWM-pulsen på CCP-pinnen.
• Nu laddas de 10 bitarna "DutyTime" från "CCPRL×4 + CCPX×2+ CCPY" till
komparatorn.
• 10-bitars komparatorn upptäcker när Timer2 räknat fram till talet för
DutyTime.
• Då 0-ställs SR-låskretsen och PWM-pulsen avslutas på CCP-pinnen.
• När Timer2 räknat fram till periodvärdet 0-ställs timern på nytt och förloppet
upprepas - allt detta utan medverkan från processorn.
PWM-frekvens, upplösning och DutyCycle
För upplösningen gäller:
För DutyCycle gäller:
Exempel (med PIC16F628)
Antag att vi har en PIC16F628 med 10 MHz klocka. Högst upplösning får man om
Timer2 räknar fullt, dvs PR2 = 255 och prescalern delar med 1/1 ( ställs in med
T2CON ). Prescalern kan ställas in på: 1:1, 1:4, 1:16 {1 4 16}.
f PWM = 10⋅10 6 / (256×4×1) = 9766 Hz
Upplösning = log(10000000/9766) / log(2) = 3/0,3 = 10 bitar
Om denna PWM-frekvens kan accepteras och om man nöjer sig med 8 bitars
upplösning blir programmeringen av DutyCycle enkel:
37

* Settings CCP1 PWM-mode */
TRISB.3 = 0; /* CCP1 is output (RB3 pin) */
PR2 = 255; /* Timer2 counts full period */
/* PWM DutyCycle */
CCPR1L = 64; /* in this example 25% DutyCycle 65/256 = 0,25 */
/* CCP1X and CCP1Y can be set to 0 for 8 bit resolution */
/* 0, 0000 (1:1 postscale), 1 (TMR2 on), 00 (1:1 prescale) */
T2CON = 0b00000100; /* Set CCP unit in PWM-mode */
CCP1CON = 0b00.0.0.1111;
/* --, 0 (CCP1X), 0 (CCP1Y), 1111 (PWMmode 11xx) */
Vill man använda en högre PWM-frekvens, tex 20 kHz för att undvika hörbara
vibrationer, laddar man PR2 med talet 124. Högsta upplösningen blir då 9 bitar.
Löst programexempel med PIC16F628
PWM-testsignal, 1000 Hz 50%
dutycycle
Detta mycket enkla testprogram visar hur PIC16F62x ställs in för att för att generera
en 1000 Hz, 50% dutycycle PWM-signal. Hemma kan testsignalerna avlyssnas med
kristall-hörluren och kanske jämföras med ett stämt musikinstrument, eller telefonens
kopplingston som är 440 Hz..
( Vid labtillfället i skolan mäter vi frekvensen med en FLUKE 123-scopmeter. )
38

PR2-registret
Om oscillatorfrekvensen är 4 MHz och Timer2's prescaler är inställd på 1/4
( T2CON ) så ska periodregistret PR2 således laddas med talet 249.
CCPR 10 bitar
50% Duty-cycle ger:
Enklaste sättet att variera Duty-cycle är nu att skriva tal mellan 0 och 249 till CCPRLregistret.
( Skriver man ett tal i CCPRL-registret som är större än talet i PR2-registret, tex 250,
så upphör PWM-signalen).
Programmet pwm1k62x.c
/* pwm1k62x.c PWM testprogram for 16f628 */
/* PWM frequency = 1000 Hz. PWM DutyCycle = 50%. */
#include "16f628.h"
#pragma config |= 0x3ff0
void main(void)
{
/* Settings CCP1 PWM-mode */
PR2 = 249;
/* 10 bit Duty 0b01111101.0.0 = 500 */
CCPR1L = 0b01111101;
/* CCP1X = 0 CCP1Y = 0 later on */
TRISB.3 = 0; /* CCP1 is output at RB3 ( pin 9 ) */
T2CON = 0b0.0000.1.01;
/* 0, 0000 (1:1 postscale), 1 (TMR2 on), 01 (1:4 prescale) */
CCP1CON = 0b00.0.0.1111;
/* --, 0 (CCP1X), 0 (CCP1Y), 1111 (PWMmode 11xx) */
while(1) nop();
}
39

Lösta programexempel med PIC16F628
Varvtalsratt till
LEGO-motor
Pulsgivare och PWM
En ratt med pulsgivare är ansluten till RB6 och RB7. I skolan ansluter vi en Legomotor
mellan RB3/CCP1 (PWM-signalen) och RA1. ( Hemma får Du nöja dig med
två antiparallella lysdioder vars ljusstyrka symboliserar motorns varvtal ).
Pulsgivaren ska användas som varvtalsratt för legomotorn (öka/minska). Full fart
uppnås när man vridit fram pulsgivaren 255 steg.
Programmet måste ignorera om man vrider fram mer än 255 steg eller bakåt förbi ”0”.
/* pwmspeed.c RB-int reads rotary switch and outputs pwm */
#include "16F628.h"
#include "int16Cxx.h"
#pragma config |= 0x3ff0
char count; /* global to accumulate pulses from sensor */
char trans; /* global to store transitions */
#pragma bit lightdiode @ PORTA.2
#pragma bit quad_A @ PORTB.6
#pragma bit quad_B @ PORTB.7
#define ON 1
#define OFF 0
40

#pragma origin 4
interrupt int_server( void )
{
int_save_registers
if( RBIF == 1 ) /* is it the RB pin change-interrupt? */
{ /* this time it's obvius that it is! */
/* read encoder new value */
trans.0 = quad_A;
trans.1 = quad_B;
/* compare with old value */
if( (trans == 0b00.01) && (count != 255) ) count ++;
if( (trans == 0b01.00) && (count != 0) ) count --;
/* replace old value with new value */
trans.2 = trans.0;
trans.3 = trans.1;
RBIF = 0; /* Reset RB-change flag before leaving */
}
int_restore_registers
}
void main( void )
{
/* the main program */
char speed;
CM0=1; CM1=1; CM2=1; /* no comparators on PORTA */
OPTION.7 = 0; /* internal pullup resistors on */
TRISA.1 = 0; /* PA1 is output. Motor GND. */
PORTA.1 = 0; /* Motor GND = 0 */
TRISB = 0b11000000; /* only inputs quad_A and quad_B */
trans = 0;
speed = 0;
RBIE = 1; /* local enable */
GIE = 1; /* global enable */
/* Settings CCP1 PWM-mode */
PR2 = 255;
TRISB.3 = 0; /* CCP1 is output (RB3-pin) */
T2CON = 0b0.0000.1.00;
/* 0, 0000 (1:1 postscale), 1 (TMR2 on), 00 (1:1 prescale) */
CCP1CON = 0b00.0.0.1111;
/* --, 0 (CCP1X), 0 (CCP1Y), 1111 (PWMmode 11xx) */
while(1)
{
speed = count;
CCPR1L = speed; /* new PWM-value */
}
}
41

Programuppgift med PIC16F628
Varvtalsratt till
LEGO-motorn,
medurs/moturs
rotation
Pulsgivare och PWM
Uppgiften är nu att med pulsgivarens ratt styra motorns varvtal i två rotationsriktningar.
När ratten vrids åt ena hållet ska hastigheten öka, om den vrids tillbaka åt andra hållet
ska den minska tills den blir ”0”. Fortsätter man nu vridningen ska motorn byta
rotationsriktning och ratten ska styra hastigheten i den andra riktningen!
Byte av rotationsriktning
Byte av rotationsriktning kan ske genom att man ändrar spänningen vid motorns
jordpunkt från ”0” till ”1”. Om jordspänningen är ”0” ger PWM-signalen en proportionell
hastighet i ena rotationsriktningen. Om jordspänningen är ”1” ger PWMsignalen
en omvänt proportionellt varvtal i den motsatta rotationsriktningen, här bör
man således programmera DutyCycle’s inverterade värde ( se figur )!
Detta låter komplicerat, men det är faktiskt enklare än det ser ut eftersom det stämmer
överens med hur datorer lagrar tal med tecken.
Om variabeln count inte är teckenlös (char) utan i stället deklareras som ett tal
med tecken ( int count; ) har den talområdet –128 < 0 < +127. Max- och mingränserna
i programmet måste då omdefinieras:
if( (trans == 0b00.01) && (count != 127) ) count ++;
if( (trans == 0b01.00) && (count != -128) ) count --;
42

Om man studerar de binära talen -128 (10000000), -1 (11111111), 0 (00000000),
+1 (00000001), +127 (01111111), ser man att den mest signifikanta biten count.7
är teckenbiten och att denna kan användas för att styra motorns rotationsriktning.
PORTA.1 = count.7; /* rotate cw or ccw */
Talcirkel. Registeraritmetik innebär att talsystemet kan ses som en "ring" - som km-räknaren på en bil.
För enkelhets skull är registerlängden i figuren fyra bitar, då räknar registret "runt" efter talet 15.
Principen är densamma för ett 8-bitars register, men det räknar runt efter talet 255.
Tal kan antingen betraktas som teckenlösa tal ( tex typ char i C ) eller som tal med tecken
( typ int i C ).
Om man fördubblar talet count får man ett lämpligt värde att styra PWM-enheten
med, detta visar nedanstående tabell:
count count.7 count*2 count count.7 count*2
+127 0 +254 -128 1 0
(01111111)
(11111110) (10000000)
(00000000)
0
0 0
-1 1 +254
(00000000)
(00000000) (11111111)
(11111110)
char speed;
speed = count*2;
CCPR1L = speed; /* new PWM-value */
Det hela passar som ”hand i handske”!
Inför dessa ändringar i programmet pwmspeed.c . Provkör
därefter programmet och styr motorn med olika varvtal och
rotationsriktningar.
43

Lösta programexempel med PIC16F628
TickClock, samplingsklocka
I mekatroniken styr man processer med hjälp av ställdon utifrån mätvärden från
givare. En mikrostyrkrets beräknar lämpliga åtgärder som sätts in vid regelbundna
tidpunkter, samplingstillfällen.
Det är verkligen viktigt att samplingsfrekvensen är konstant, eftersom storleken på en
åtgärd naturligtvis måste bero på hur ofta som den utförs.
En mycket vanlig programmeringsuppgift är därför att generera regelbundna
programavbrott, med en sk samplingsklocka. Man kan se detta som det mekatroniska
systemets hjärtslag!
PIC-processorerna är förberedda för att enkelt kunna utföra detta.
TIMER2 som samplingsklocka
TIMER2:s periodtid är mycket enkel att påverka med ett 8-bitars periodregister PR2.
Den har dessutom både en postscaler ( 1/1 1/4 1/16 ) och en prescaler ( 1/1 ... 1/16 ).
När postscalern "slår runt" sätts en flagga TMR2IF och då kan även interruprutinen
köras om man programmerat detta.
Ofta används TIMER2 för generering av PWM-signaler. Postscalern ingår inte för
genereringen av PWM-frekvensen, men den kan ändå användas som
samplingsklocka.
44

Antag att vi har 4 MHz kristall och att vi behöver en 750 Hz samplingsklocka (tex för
att uppdatera PWM-signalen). TIMER2:s prescaler är 1/1 och periodregistret
PR2=255. ( Jämför med exemplet Varvtalsratt till LEGO-motorn ). PWMfrekvensen
blir:
10 6 /256 = 3906 Hz. För att få en 750 Hz samplingsklocka måste vi dela
pwmfrekvensen med 5 med postscalern. 3906/5 = 750 Hz.
Programmet kan provas genom att man kontrollerar att har en ton med frekvensen
750/2 Hz på pinne RB0 och att man har en ton med frekvensen 3906 Hz från CCP1
pinnen RB3.
/* pwmclk.c sampleclock 750 Hz with TIMER2 and pwm 3000 Hz */
#include "16F628.h"
#include "int16Cxx.h"
#pragma config |= 0x3ff0
#pragma origin 4
interrupt int_server( void )
{
int_save_registers
if( TMR2IF == 1 ) /* test if it is the TMR2I-interrupt? */
{ /* this time it's obvius that it is! */
PORTB.0 = !PORTB.0; /* togle earphone, 750/2 Hz tone at RB0 */
TMR2IF = 0; /* Reset TMR2IF-flag before leaving */
}
int_restore_registers
}
void main( void )
{
/* the main program */
TRISB.0 = 0; /* RB0 output to earphone */
PORTB.0 = 0;
/* Settings CCP1 PWM-mode */
PR2 = 255;
/* 10 bit startup Duty 0b01111101.0.0 */
CCPR1L = 127; /* startup value */
/* CCP1X = 0 and CCP1Y = 0 later on in CCP1CON */
TRISB.3 = 0; /* CCP1 is output (RB3-pin) 3000 Hz tone */
T2CON = 0b0.0100.1.00;
/* 0, 0100 (1:5 postscale), 1 (TMR2 on), 00 (1:1 prescale) */
CCP1CON = 0b00.0.0.1111;
/* --, 0 (CCP1X), 0 (CCP1Y), 1111 (PWMmode 11xx) */
TMR2IE = 1; /* local enable */
PEIE = 1; /* regional enable */
GIE = 1; /* global enable */
while( 1 ) nop(); /* main program has nothing to do ! */
}
45

PIC16F87x, AD-omvandlarens
referensspänning
Blockschema över PIC-midrangekretsarnas AD-enhet.
Matningsspänningen som spänningsreferens
För att kunna mäta analoga spänningar har PIC-midrangekretsarna en 10-bitars ADomvandlare.
Med hjälp av en inbyggd sk. multiplexer har man möjlighet att ansluta
omvandlaren till en i taget av 8 portpinnar. Som referens vid AD-omvandlingen
används antingen kretsens matningsspänning, (V SS , V DD ), eller så kan man ansluta
yttre spänningsreferenser genom två av portpinnarna. Det enklaste är naturligtvis att
använda matningsspänningen som referens, men det kan finnas olika anledningar till
att använda yttre spänningsreferens.
Yttre precisionsreferens
Antag att PIC-processorn ska användas som en noggrann voltmeter. Det är då viktigt
att den uppmätta spänningen jämförs med en exakt referens. Om utrustningen
tillexempel är batteridriven, så varierar matningspänningen för mycket för att vara
lämplig som referensspänning.
46

PIC-processor som Voltmeter.
Man kan ansluta en yttre referensspänning till ingången AN3. Det finns utmärkta
spänningsreferenskretsar att köpa, tex kretsen MAX6241, som har spänningen 4,096
V. Detta "ovanliga" spänningsvärde kommer av att talet 4096 är en tvåpotens, 2 12 =
4096. Med den referensspänningen får AD-omvandlaren skalfaktorn 4 mV/steg vilket
innebär att mätvärdet kan presenteras direkt, utan att behöva skalas om med
multiplikation/division. Division med "4" kan man utföra genom att "skifta" det
binära talet två steg åt höger.
(Multiplikationer och divisioner innebär mycket programkod för processorer som
saknar inbyggd multiplikatorenhet).
Högsta upplösning
Vill man ha högsta upplösning vid mätning av givarsignaler måste man se till att
givarens utspänningsområde och det spänningsområde AD-omvandlaren omvandlar
helt "täcker" varandra. I allmänhet krävs det då att både AD-omvandlarens
referensspänning och 0-nivå kan justeras.
Hög upplösning kräver att AD-omvandlarens referensspänning och 0-nivå kan justeras efter givarens
spänningsområde.
Med de två potentiometrarna i figuren kan AD-omvandlarens referensspänning
(V REF+ ) ställas in mellan 2,5-5V och 0-nivå (V REF- ) mellan 0-2,5V. Genom att
potentiometrarna är seriekopplade riskerar man inte att av misstag kunna ställa in en
referensnivå som är lägre än 0-nivån.
47

Anslutning av en termistor
Ett praktiskt exempel är temperaturmätning med en NTC-termistor. En termistor har
hög känslighet, men olinjärt temperatursamband.
I praktiken seriekopplar man termistorn med en fast resistor så att den ingår i en
spänningsdelare. ( Tekniken beskrivs i boken Mätgivare ). Figuren visar sambandet
mellan spänning och temperatur för en sådan spänningsdelare. Kurvan börjar vid 0,5
V och slutar vid 3,5V och blir däremellan förvånadsvärt linjär.
Genom att ställa in V REF- = 0,5V och V REF+ = 3,5V med potentiometrarna, så utnyttjar
temperaturgivaren AD-omvandlarens hela spänningsområde.
48

Ratiometrisk anslutning
Ratiometrisk anslutning av potentiometergivare till en AD-omvandlare.
Som referensspänning kan den ostabiliserade matningsspänningen användas!
Ibland behöver man stabila referensspänningar både till givare och AD-omvandlare.
Ett ofta använt konstgrepp är då ratiometrisk anslutning av givaren. Så länge
givarens referensspänning och AD-omvandlarens referensspänning ändrar sig i
samma proportioner så omvandlas samma värde.
Om man har samma referensspänning till givare och AD-omvandlare så ställs det
därför inga krav på att den ska vara stabil.
AD-omvandlare förses av detta skäl ofta med separata anslutningar för
matningspänning och jord till sina analoga respektive digitala delar.
( V DD V SS V REF+ V REF- ).
Det viktiga är att båda referensspänningarna ansluts till samma punkter så att de
utsätts för samma "störningar".
PIC-processorn har separat anslutning för AD-omvandlarens referensspänning genom
pinnarna AN2 och AN3.
( Tekniken beskrivs i boken Mätgivare ).
49

PIC16F87x AD-omvandling, steg för
steg (utan användning av interrupt)
1. Konfigurera AD-modulen
Konfigurera analoga ingångar och referensspänningar (eller digitital
I/O). Register ADCON1.
• Välj AD-ingångskanal. Register ADCON0.
• Bestäm AD-omvandlarens klockfrekvens. Register ADCON0.
• Sätt på AD-modulen! Register ADCON0.
• Välj format på hur 10-bitstalet ska justeras. Register ADCON1.
Exempel:
ADCON0=0bxxxxxxxx; ADCON1=0bxxxxxxxx; TRISA=0bxxxxxxxx;
TRISE=0bxxxxxxxx;
2. Vänta inställningstiden ( acquistion time ).
• Acquistion time t ACQ är av storleksordningen 20 µs. Exempel på hur man
programmerar 20 µs ungefärlig fördröjningstid (tids-spill) vid 4 MHz
klockfrekvens:
char i = 3; do ; while ( --i > 0);
3. Starta AD-omvandlingen.
• Ettställ GO/DONE biten. Register ADCON0. Kodexempel:
GO = 1;
4. Vänta tills AD-omvandlingen är klar.
• Vänta ut att biten GO/DONE blir 0. Exempel på programkod:
while( GO );
5. Läs av AD-omvandlaren.
• 8 bitar, ADRES vänsterjusterat. Kodexempel:
char answer;
answer=ADRESH;
• 10 bitar, ADRES högerjusterat. Kodexempel:
unsigned long answer;
answer = 256*ADRESH; answer += ADRESL;
( ADRES finns fördefinierad i headerfilen 16f874.h som ADRESH och ADRESL,
GO/DONE finns fördefinierad i headerfilen 16f874.h som GO )
50

PIC16F874
Blinkfrekvensen styrs av potentiometern
/* ADtest.c testprogram for 16f874 */
/* Blinkfrequency at RD0 varies with voltage on AN0 */
#include "16f874.h"
#pragma config |= 0x3ff2
#pragma bit out @ PORTD.0
void main(void)
{
char i, j, answer, blinktime;
TRISD.0 = 0; /* lightdiode at RD0 is output */
out = 1;
/* AD Setup. Se help Script! */
/* "fosc/8"."AN0"."go=0"."-"."on" */
ADCON0 = 0b01.000.0.0.1;
/* "leftjust"."fosc/8"."--"."internal ref, Vref+=Vcc, Vref-=Vss" */
ADCON1 = 0b0.1.00.1110;
TRISA.0 = 1; /* AN0 is input */
while(1)
{
char i = 3; do ; while ( --i 0); /* wait tACQ */
GO=1; /* start AD */
while(GO); /* wait for done */
blinktime = ADRESH; /* read result 8 msb */
/* double loop i,j generates blinkfrequency */
for( i=0;i < blinktime; i++)
{
for( j=0;j < 250; j++);
}
/* toggle lightdiode on/off */
out = ! out;
}
}
51

JSP-diagram för AD-testprogram. Med en potentiometer till AD-omvandlaren kan man styra en
lysdiods blinkfrekvens.
52