Lidt c code til Siemens 80535 up.
Sådan gør man det, her er også andre nyttige sup's der kan benyttes til 80535 Kittet. Alt er lavet af mig, og må benyttes frit. Delay funktion er designet til et 11,059MHz XTal.
'main' i dette exempel er bare noget lal til at teste med, se bort fra den, det skal du jo selv lave.
Jeg kan ikke huske hvilken c compiler jeg brugte.
Husk på at code og hardware forbindelser skal tilpasses.
Du skal først lave noget analog elektronik der kan omdanne lys til spænding 0..5Vdc. Som ledes til en af ialt 8 analoge input på 80535, her kan du vælge at converter i enten 8 eller 10 bit, derefter kan du manipulere med værdien som du vil i coden, måske indbygge liniarisering for compensation af den analoge del, eller noget med alarmer, og,og,og derudaf.
NB:Det er første gang jeg svare her på Experten, jeg hved ikke hvordan man vedhefter et dokument så det er synligt for alle.
mvh Dan
#pragma code= 0x4000 //{$M $4000 $0} offset addr
#pragma model=large; // Ext RAM
// Program til 80535 Kittet. Benyttes til udvikling
// Sidste revidering, 29-AUG-1998.Dan Nielsen
// #################################################
// I dette program er der benyttet lysdioden på
// 80535 kittet. Lysdioden er forbundet til p5.6
// Port 4 er benyttet til et LCD display, Port 4 er data.
// P5.0=LCD(RS),P5.1=LCD(R/W),P5.2=LCD(E).
// Interrupt0 ben p3.2 er,forbundet til en tryk swits til gnd.
// RS232 seriel porten. Der er ingen handshake på
// serielport. Seriel com er sat til 1-Startbit,
// 1-stopbit, 8-Databit, 9600-Baud.
// *********** PROGRAM NAVN START.C ****************
// ========================================================
// Benyttede globale moduler
// --------------------------------------------------------
//#define __PRINTF__
#include <stdio.h>
//#include <string.h>
//#pragma data =0x800;
#pragma parameters=xdata;//compiler directive hardware har ext RAM
// --------------------------------------------------------
// ========================================================
// Preprossor definitioner
// --------------------------------------------------------
#define ESC 27
#define TRUE 1
#define FALSE 0
#define LED P5.6 //Led på Kit
#define MAX 1200 //Tabel maximale længde
#define LCD_E P5.2 //LCD styre signal "Enable" LCD pin 6
#define LCD_RW P5.1 //LCD styre signal "Read/Write" LCD pin 5
#define LCD_RS P5.0 //LCD styre signal "Register Select" pin 4
#define LCDPORT P4 //LCD Data "8 bit Data " LCD pin 7..14
#define DISPLAY 16 //LCD antal karaktere pr række
// ------------ --------------------------------------------
// ========================================================
// Functions prototyper
// --------------------------------------------------------
// Timer 1 interrupt, benyttes til RS232 Baud-rate generator
void inctimer (...); // Timer0, benyttes til delay
void delay (unsigned int); // Delay i msek
void inter0 (...); // Interupt0, P3.2
void inter1 (...); // Interupt1, P3.3
void init (void); // Global samling af initialisering
void ok (void); // hjælpe test af programmering
void Inte_rupt_init (void); // initialiser interupt
void polling_int (void); //skal gennemløbes jævnligt
void serial_init_9600 (void); // RS232 Seriel initialicering
void serial_init_19200 (void); // RS232 Seriel initialicering
void serial_init_57600 (void); // RS232 Seriel initialicering
void newline (void); // RS232 retur og linie skift
void txbyte (unsigned char); // RS232 Sender en byte seriel
unsigned char rexbyte (void); // RS232 modtag en byte seriel
unsigned char adc8bit (unsigned char); // A/D, 8-bit one meas
unsigned int adc10bit (unsigned char); // A/D, 10-bit two meas
unsigned int volt (unsigned int); // A/D, fra int til spænding
void lcd_init (void); // LCD-Funktioner Initialiser LCD
void lcd_command (unsigned char); // LCD-Funktioner comand to LCD
void lcd_data (unsigned char); // LCD-Funktioner data til LCD
void lcd_busy (void); // LCD-Funktioner busy flag
void lcd_pos (unsigned char); // LCD-Funktioner position
void lcd_dansk (void); // LCD-Funktioner Danske tegn
void lcd (unsigned char*);// LCD-Funktioner skriv til LCD
unsigned char* ord (unsigned int); // ordiner value of int to string
// --------------------------------------------------------
// ========================================================
// Globale Konstanter lagt i ROM
// --------------------------------------------------------
// Tabel for Analog to Digital 10 bit converter function, in ROM
// adc10bit range[ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
const unsigned char range[]={0x00,0x40,0x62,0x84,0xA6,0xC8,0xEA,0x0C};
// Tabel for Dansk tegnsæt, pladseres i ROM
const unsigned char dansk[]=
{
0x1f,0x14,0x14,0x1f,0x14,0x14,0x17,0x00, // Æ
0x01,0x0e,0x13,0x15,0x19,0x0e,0x10,0x00, // Ø
0x04,0x0a,0x0e,0x11,0x1f,0x11,0x11,0x00, // Å
0x00,0x00,0x1e,0x05,0x1f,0x14,0x0f,0x00, // æ
0x00,0x00,0x01,0x0e,0x0a,0x0e,0x10,0x00, // ø
0x04,0x0a,0x0e,0x01,0x0f,0x11,0x0f,0x00 // å
};
// ========================================================
// Globale variable
// --------------------------------------------------------
bit int_0 ; //: Boolean; INT0 kontrol Bit
bit int_1 ; //: Boolean; INT1 kontrol Bit
xdata unsigned char rx_byte ; //: byte; RAM
unsigned int taeller ; //: word; idata
xdata bit stopbit ; //: Boolean; RAM
xdata unsigned int sec,frac; //: Delay variabel i RAM
xdata unsigned int delayfrac; //: Delay variabel i RAM
xdata unsigned int tael,pp ; //: Word; universal variable
xdata unsigned char tabel[MAX+2]; //: Global tabel 8bit
// --------------------------------------------------------
// ########################################################
// ########################################################
main()
{
init();
lcd_init();
while (!stopbit)
{
polling_int();
delay(22);
pp=adc10bit(0);
printf("%8.u",pp);
lcd_pos(3);
lcd("æøåÆØÅ");
lcd_pos(16);
printf("\npp er = %u stor",pp);
pp=adc10bit(0);
lcd_pos(0);
lcd("Integer =");
lcd(ord(pp));
lcd_pos(16);
lcd("Spænding=");
lcd(ord(volt(pp)));
printf("\n%s",ord(volt(pp)));
for(tael=0;tael<MAX;tael++)
{
tabel[tael]=0xff;
pp=tabel[tael];
if(pp!=tabel[tael]) printf(" fejl ved addr=%s",ord(tael));
tabel[tael]=0x00;
pp=tabel[tael];
if(pp!=tabel[tael]) printf(" fejl ved addr=%s",ord(tael));
}
delay(30);
ok();
}// end "while(!stopbit)"
}
// ########################################################
// --------------------------------------------------------
// lcd_pos(0);
// lcd(" Æ Ø Å æ ø å 0");
// LCD
// --------------------------------------------------------
void lcd(unsigned char *s)
{
// s indeholder abs addr, p benyttes som addr counter
unsigned char *p=s;
while(*p != '\0') //mendens indholdet *p peger på, ikke er '\0'
{
switch(*p)
{
case 'Æ': lcd_data(0);break;
case 'Ø': lcd_data(1);break;
case 'Å': lcd_data(2);break;
case 'æ': lcd_data(3);break;
case 'ø': lcd_data(4);break;
case 'å': lcd_data(5);break;
default : lcd_data(*p);break;
}// end switch
p++;
} // end while
}
// --------------------------------------------------------
// LCD
// Dansk tegn sæt Æ,Ø,Å,æ,ø,å OK 21 AUG 1998 Dan Nielsen
// --------------------------------------------------------
void lcd_dansk(void)
{
unsigned char dum;
//const unsigned char dansk[]=
// {
// 0x1f,0x14,0x14,0x1f,0x14,0x14,0x17,0x00, // Æ
// 0x01,0x0e,0x13,0x15,0x19,0x0e,0x10,0x00, // Ø
// 0x04,0x0a,0x0e,0x11,0x1f,0x11,0x11,0x00, // Å
// 0x00,0x00,0x1e,0x05,0x1f,0x14,0x0f,0x00, // æ
// 0x00,0x00,0x01,0x0e,0x0a,0x0e,0x10,0x00, // ø
// 0x04,0x0a,0x0e,0x01,0x0f,0x11,0x0f,0x00 // å
// };
lcd_command(0x40);
for(dum=0;dum<8*6;lcd_data(dansk[dum]),dum++);
}
// --------------------------------------------------------
// LCD Row=2, collum == "DISPLAY"
// Row 0 = 00..DISPLAY-1 if DISPLAY==40 then 00..39
// Row 1 = DISPLAY..(DISPLAY*2)-1 40..79
// --------------------------------------------------------
void lcd_pos(unsigned char pos)
{
unsigned char dummy;
dummy=64-DISPLAY;
lcd_busy(); // vent til LCD Display er klar
if(pos>=DISPLAY)
{
pos=pos+dummy;
}
lcd_command(pos+0x80); //
}
// --------------------------------------------------------
// LCD
// --------------------------------------------------------
void lcd_command(unsigned char inp)
{
lcd_busy(); // vent til LCD Display er klar
LCD_RS=FALSE; // True=Data input, False=Command input
LCD_RW=FALSE; // True=Read, False=Write
LCD_E=TRUE; // Enabel LCD Display
LCDPORT=inp; // skriv til port 4
delay(1); // vent lidt
LCD_E=FALSE; // Enabel LCD Display
}
// --------------------------------------------------------
// --------------------------------------------------------
void lcd_data(unsigned char inp)
{
lcd_busy(); // vent til LCD Display er klar
LCD_RS=TRUE; // True=Data input, False=Command input
LCD_RW=FALSE; // True=Read, False=Write
LCD_E=TRUE; // Enabel LCD Display
LCDPORT=inp; // skriv til port 4
delay(1); // vent lidt
LCD_E=FALSE; // Enabel LCD Display
LCD_RS=FALSE; // True=Data input, False=Command input
}
// --------------------------------------------------------
// LCD Functioner
// --------------------------------------------------------
void lcd_init(void)
{
unsigned char dummy;
dummy = LCDPORT ; // P4 input
dummy = 0x38; // Function Set value
delay(100); // Power on wait
lcd_command(dummy); // System Function 1
delay(100); // Power on wait
lcd_command(dummy); // System Function 2
delay(100); // Power on wait
lcd_command(dummy); // System Function 3
delay(100); // Power on wait
lcd_command(dummy); // system Function set 4 gange ialt
delay(5);
lcd_command(0x0c); // Display ON/OFF Control
delay(5);
lcd_command(0x06); // Entry Mode Set
delay(5);
lcd_command(0x18); // Cursor or Display Shift
delay(5);
lcd_command(0x02); // home
delay(5);
lcd_command(0x01); // Clear
delay(5);
lcd_dansk(); // Dansk tegn sæt ÆÅØæøå 0..5
LCD_E=FALSE; // Enabel LCD Display
LCD_RS=FALSE; // True=Data input, False=Command input
LCD_RW=FALSE; // True=Read, False=Write
dummy = LCDPORT ; // P4 input
}
// --------------------------------------------------------
// LCD_busy , OK, Testet 21 AUG 1998 Dan Nielsen
// bliver hængende i rutine indtil display er klar
// --------------------------------------------------------
void lcd_busy(void)
{
unsigned char dummy;
dummy=LCDPORT; // P4 input
LCD_RW=TRUE; //
LCD_RS=FALSE; //
LCD_E=TRUE; // set kontrol pins
while(LCDPORT.7); // vent intil P4.7 low
LCD_E=FALSE; // reset kontrol pins
LCD_RS=FALSE; //
LCD_RW=FALSE; //
dummy=LCDPORT; // P4 input
return();
}
// --------------------------------------------------------
// ord() , OK, Testet 21 AUG 1998 Dan Nielsen
// returnere addressen på en string der indeholder værdien af int
// --------------------------------------------------------
unsigned char* ord(unsigned int x)
{
xdata unsigned char s[5]; // text string
unsigned int y;
// find antal 10000 og læg antal i første position i string
if (x >= 0 && x <= 9999) { y=x- 0; s[0]='0'; }
else if (x >= 10000 && x <= 19999) { y=x-10000; s[0]='1'; }
else if (x >= 20000 && x <= 29999) { y=x-20000; s[0]='2'; }
else if (x >= 30000 && x <= 39999) { y=x-30000; s[0]='3'; }
else if (x >= 40000 && x <= 49999) { y=x-40000; s[0]='4'; }
else if (x >= 50000 && x <= 59999) { y=x-50000; s[0]='5'; }
else if (x >= 60000 && x <= 65535) { y=x-60000; s[0]='6'; }
else { y=0; s[0]='0'; }
x=y;
//nu er talet under 10000
// find antal 1000 og læg antal i anden position i string
if (x >= 0 && x <= 999) { y=x- 0; s[1]='0'; }
else if (x >= 1000 && x <= 1999) { y=x- 1000; s[1]='1'; }
else if (x >= 2000 && x <= 2999) { y=x- 2000; s[1]='2'; }
else if (x >= 3000 && x <= 3999) { y=x- 3000; s[1]='3'; }
else if (x >= 4000 && x <= 4999) { y=x- 4000; s[1]='4'; }
else if (x >= 5000 && x <= 5999) { y=x- 5000; s[1]='5'; }
else if (x >= 6000 && x <= 6999) { y=x- 6000; s[1]='6'; }
else if (x >= 7000 && x <= 7999) { y=x- 7000; s[1]='7'; }
else if (x >= 8000 && x <= 8999) { y=x- 8000; s[1]='8'; }
else if (x >= 9000 && x <= 9999) { y=x- 9000; s[1]='9'; }
else { y=0; s[1]='0'; }
x=y;
//nu er talet under 1000
// find antal 100 og læg antal i tredie position i string
if (x >= 0 && x <= 99) { y=x- 0; s[2]='0'; }
else if (x >= 100 && x <= 199) { y=x- 100; s[2]='1'; }
else if (x >= 200 && x <= 299) { y=x- 200; s[2]='2'; }
else if (x >= 300 && x <= 399) { y=x- 300; s[2]='3'; }
else if (x >= 400 && x <= 499) { y=x- 400; s[2]='4'; }
else if (x >= 500 && x <= 599) { y=x- 500; s[2]='5'; }
else if (x >= 600 && x <= 699) { y=x- 600; s[2]='6'; }
else if (x >= 700 && x <= 799) { y=x- 700; s[2]='7'; }
else if (x >= 800 && x <= 899) { y=x- 800; s[2]='8'; }
else if (x >= 900 && x <= 999) { y=x- 900; s[2]='9'; }
else { y=0; s[2]='0'; }
x=y;
//nu er talet under 100
// find antal 10 og læg antal i fjerde position i string
if (x >= 0 && x <= 9) { y=x- 0; s[3]='0'; }
else if (x >= 10 && x <= 19) { y=x- 10; s[3]='1'; }
else if (x >= 20 && x <= 29) { y=x- 20; s[3]='2'; }
else if (x >= 30 && x <= 39) { y=x- 30; s[3]='3'; }
else if (x >= 40 && x <= 49) { y=x- 40; s[3]='4'; }
else if (x >= 50 && x <= 59) { y=x- 50; s[3]='5'; }
else if (x >= 60 && x <= 69) { y=x- 60; s[3]='6'; }
else if (x >= 70 && x <= 79) { y=x- 70; s[3]='7'; }
else if (x >= 80 && x <= 89) { y=x- 80; s[3]='8'; }
else if (x >= 90 && x <= 99) { y=x- 90; s[3]='9'; }
else { y=0; s[3]='0'; }
x=y;
//nu er talet under 10
// find rest og læg i femte position i string
if (x == 0) s[4]='0';
else if (x == 1) s[4]='1';
else if (x == 2) s[4]='2';
else if (x == 3) s[4]='3';
else if (x == 4) s[4]='4';
else if (x == 5) s[4]='5';
else if (x == 6) s[4]='6';
else if (x == 7) s[4]='7';
else if (x == 8) s[4]='8';
else if (x == 9) s[4]='9';
else s[4]='0';
s[5]='\0'; // Afslut string men NULL i sjete position
// printf("\n%s",&s);
return(&s); // Returnere adresse værdien på string
}
// --------------------------------------------------------
// Timer 0 interrupt, optages til delay function
// --------------------------------------------------------
void inctimer () interrupt TIMER0
{
// This interrupt will come every 200 micro second
// and update the delayfrac variable every 1/1000 second
if (frac++ >= 5) //benyt 3905 for 1 sek delay function
{
delayfrac++;
frac = 0;
}
}
// --------------------------------------------------------
// ******** Delay i milli sekunder *********************
// tjekket 21 AUG 1998 af Dan Nielsen, Køre ok
// --------------------------------------------------------
void delay(unsigned int ms) // Delay i msek
{
delayfrac = 1; //
while(ms >= delayfrac); // Gennem løbes mindst en gang
}
// --------------------------------------------------------
// --------------------------------------------------------
void init(void)
{
stopbit=FALSE;
Inte_rupt_init(); // interrupt initialisering
serial_init_9600(); // Seriel initialicering
// serial_init_19200(); // Seriel initialicering
// serial_init_57600(); // Seriel initialicering
}
// --------------------------------------------------------
// ********************** ok *************************
// Skal ikke bruges i den endelige code. Kun til test
// --------------------------------------------------------
void ok(void) // hjælpe test af programmering
{ // tænder og slukker LYSDIODE p5.6
LED=!LED; // Inverterer Lysdiode }
}
// --------------------------------------------------------
// *********** Seriel Port *** 9600 baud **************
// Denne procedure skal kun bruges når seriel port skal
// sættes op. Her er sat til 1start, 1stop, 8 data bit
// Med et 11,059MHz XTal monteret, timer 1 benyttes som
// baudrate generator i mode 2 8-bit auto reload.
// denne funktion er ok DMN JAN-1998.
// --------------------------------------------------------
void serial_init_9600(void) // Seriel initialicering
{ // 1-start, 8-data, 1-stop,
unsigned char dummy; // no-parity, async.
SCON = 0x7C; // Seriel mode 1: 8-bit UART
ADCON &= 0x7F; // Baud Rate Disable, BD=FALSE
PCON &= 0x7F; // $7F = "SMOD" sat FALSE
TMOD |= 0x20; // timer1 mode2 8bit autoreload
TH1 = 0xFD; // BaudRate 1200=E8,2400=F4,4800=FA,9600=FD
ET1 = FALSE; // Timer 1 intr Disable
TR1 = TRUE; // turn timer/counter 1, on
TI = TRUE; // tømmer TX buffer ???
dummy = SBUF; // tømmer RX buffer ???
RI = FALSE; // Klar til at modtage
}
// --------------------------------------------------------
// *********** Seriel Port *** 19200 baud **************
// Denne procedure skal kun bruges når seriel port skal
// sættes op. Her er sat til 1start, 1stop, 8 data bit
// Med et 11,059MHz XTal monteret, timer 1 benyttes som
// baudrate generator i mode 2 8-bit auto reload.
// denne funktion er ok DMN JAN-1998.
// --------------------------------------------------------
void serial_init_19200(void) // Seriel initialicering
{ // 1-start, 8-data, 1-stop,
unsigned char dummy; // no-parity, async.
SCON = 0x7C; // Seriel mode 1: 8-bit UART
ADCON &= 0x7F; // Baud Rate Disable, BD=FALSE
PCON |= 0x80; // $80 = "SMOD" sat TRUE
TMOD |= 0x20; // timer1 mode2 8bit autoreload
TH1 = 0xFD; // BaudRate 19200=0xFD
ET1 = FALSE; // Timer 1 intr Disable
TR1 = TRUE; // turn timer/counter 1, on
TI = TRUE; // tømmer TX buffer ???
dummy = SBUF; // tømmer RX buffer ???
RI = FALSE; // Klar til at modtage
}
// --------------------------------------------------------
// *********** Seriel Port *** 57600 baud **************
// Denne procedure skal kun bruges når seriel port skal
// sættes op. Her er sat til 1start, 1stop, 8 data bit
// Med et 11,059MHz XTal monteret, timer 1 benyttes som
// baudrate generator i mode 2 8-bit auto reload.
// denne funktion er ok DMN AUG-1998.
// --------------------------------------------------------
void serial_init_57600(void) // Seriel initialicering
{ // 1-start, 8-data, 1-stop,
unsigned char dummy; // no-parity, async.
SCON = 0x7C; // Seriel mode 1: 8-bit UART
ADCON &= 0x7F; // Baud Rate Disable, BD=FALSE
PCON |= 0x80; // $80 = "SMOD" sat TRUE
TMOD |= 0x20; // timer1 mode2 8bit autoreload
TH1 = 0xFF; // BaudRate 57600=0xFF
ET1 = FALSE; // Timer 1 intr Disable
TR1 = TRUE; // turn timer/counter 1, on
TI = TRUE; // tømmer TX buffer ???
dummy = SBUF; // tømmer RX buffer ???
RI = FALSE; // Klar til at modtage
}
// --------------------------------------------------------
// Modtag en Byte fra seriel port
// --------------------------------------------------------
unsigned char rexbyte(void) // Seriel initialicering
{
while(!RI); // vent på modtager klar
RI=FALSE; // gør klar til at modtag igen
return(SBUF); // læg modtaget byte i RX_Byte
}
// --------------------------------------------------------
// Sender en Byte ad gangen Feks. txbyte(13) = Line Feed
// --------------------------------------------------------
void txbyte(unsigned char send)
{
while(!TI); // vent til txd er klar
SBUF = send; // læg i tx buffer
TI = FALSE; // send indhold af TX buffer
}
// --------------------------------------------------------
// Sender line Feed and Return
// --------------------------------------------------------
void newline(void)
{
txbyte(13); // line feed
txbyte(10); // return
}
// --------------------------------------------------------
// --------------------------------------------------------
// --------------------------------------------------------
// ************** A/D CONVERTER 8 Bit *******************
// Denne Function returnere en Byte, der representere Målt
// Spænding på AD-Port(X). 0= 0 mV, 255= +5000 mVolt
// Eks: Volt=adc8bit(2); måler fra port"AN2".
// Ved 2.5Volt på AD-Port 2, vil retur værdi blive 127;
// --------------------------------------------------------
unsigned char adc8bit (unsigned char portnr)
{
ADM = FALSE; // ADM '0' en conversion
ADCON |= portnr; // Mål på portnr "portnr"
DAPR = 0x00; // trig ved at skrive til DAPR
while(BSY); // Vent til måling er færdig
return(ADDAT); // Hent resultat i "ADDAT"
}
// --------------------------------------------------------
// ************** A/D CONVERTER 10 Bit *****************
// Denne Function returnere en Integer, der representere Målt
// Spænding på AD-Port(X). 0= 0 mV, 1023= +5000 mVolt
// Eks: Volt=adc10bit(2); måler fra port "AN2".
// Ved 2.5Volt på AD-Port 2, vil retur værdi blive 512;
// --------------------------------------------------------
int adc10bit(unsigned char portnr)
{
unsigned char dum,measure;
int offset;
//const unsigned char range[]={0x00,0x40,0x62,0x84,0xA6,0xC8,0xEA,0x0C};
// range[ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
// max min hex
// range[0]=%0000 0000; 0x00 Fra 5.000 til 0.000 Volt
// range[1]=%0100 0000; 0x40 Fra 1.250 til 0.000 Volt
// range[2]=%0110 0010; 0x62 Fra 1.875 til 0.625 Volt
// range[3]=%1000 0100; 0x84 Fra 2.500 til 1.250 Volt
// range[4]=%1010 0110; 0xA6 Fra 3.125 til 1.875 Volt
// range[5]=%1100 1000; 0xC8 Fra 3.750 til 2.500 Volt
// range[6]=%1110 1010; 0xEA Fra 4.375 til 3.125 Volt
// range[7]=%0000 1100; 0x0C Fra 5.000 til 3.750 Volt
ADM = FALSE; // ADM '0' one conversion
ADCON |= portnr; // Mål på portnr "portnr"
DAPR = range[0]; // trig ved at skrive til DAPR
while(BSY); // Vent til måling er færdig
measure=ADDAT; // Hent resultat i "ADDAT"
// i hvilket område ligger spændingen ??
if ( (00 <= measure) && (measure <= 48 ) ) { dum=1; offset= 0; }
if ( (49 <= measure) && (measure <= 80 ) ) { dum=2; offset=128; }
if ( (81 <= measure) && (measure <= 112) ) { dum=3; offset=256; }
if ( (113 <= measure) && (measure <= 144) ) { dum=4; offset=384; }
if ( (145 <= measure) && (measure <= 176) ) { dum=5; offset=512; }
if ( (177 <= measure) && (measure <= 208) ) { dum=6; offset=640; }
if ( (209 <= measure) && (measure <= 255) ) { dum=7; offset=768; }
// Skift til nærmeste spændings område og mål igen
DAPR = range[dum]; // trig ved at skrive til DAPR
while(BSY); // Vent til måling er færdig
measure=ADDAT; // Hent resultat i "ADDAT"
// læg målt spænding sammen med start af område
offset += measure; // type convertering
return(offset);
}
// --------------------------------------------------------
// Volt beregning
// --------------------------------------------------------
unsigned int volt(unsigned int vaerdi)
{
unsigned int tal,temp;
temp= vaerdi * 50;
tal=temp / 10.23;
return (tal);
}
// --------------------------------------------------------
// --------------------------------------------------------
// ******************** INTERUPT *************************
// Initialisering af interrupt rutiner, her skal kun tændes
// for de interrupt's, som man ønsker at bruge. Se manual
// Jeg har valgt at aktivere alle interrupt, EAL:=TRUE
// Derefter skal de individuelle interrupt's settes.
// Dette er afhængig af de hvad man skal bruge.
// Efter hardware Reset, Resettes alle interrupt registre
// --------------------------------------------------------
void Inte_rupt_init(void)
{
TMOD |= 0x02; // Timer1 M1 true: 8 bit autoreload timer */
EX0 =TRUE; // Ext int_0 Enable p3.2
IT0 =TRUE; // Bagkant trig af int0 signal
EX1 =TRUE; // Ext int1 Enable p3.3
IT1 =TRUE; // Bagkant trig af int1 signal
ES =FALSE; // Seriel channel intr Disable
TR0 =TRUE;
ET0 =TRUE; // Timer 0 intr Enable
TH0 =72; // interrupt every 200 microsecond (if 11MHz clock)
ET1 =FALSE; // Timer 1 intr Disable
ET2 =FALSE; // Timer 2 intr Disable
EADC =FALSE; // A/D Converter intr Disable
EX2 =FALSE; // Ext int2 Disable p1.4
EX3 =FALSE; // Ext int3 Disable p1.0
EX4 =FALSE; // Ext int4 Disable p1.1
EX5 =FALSE; // Ext int5 Disable p1.2
EX6 =FALSE; // Ext int6 Disable p1.3
EXEN2=FALSE; // Timer 2 Ext reload Disable
P3.2 =TRUE; // Interrupt.0 Reset p3.2
P3.3 =TRUE; // Interrupt.1 Reset p3.3
int_0=FALSE; // Reset boolean
int_1=FALSE; // Reset boolean
EAL =TRUE; // Enable All interrupt's
}
// --------------------------------------------------------
// Dette exekveres når INT0 aktiveres, der sætttes et
// flag (int_0), som skal resette manuelt efter brug.
// --------------------------------------------------------
void inter0 ( ) interrupt INT0
{
// printf("\n Interrupt '0' er er blevet aktiveret");
int_0=TRUE; // extern int0 port3.2
}
// --------------------------------------------------------
// Dette exekveres når INT1 aktiveres, der sætttes et
// flag (int_0), som skal resette manuelt efter brug.
// --------------------------------------------------------
void inter1 ( ) interrupt INT1
{
int_1=TRUE; // extern int1 port3.3
}
// --------------------------------------------------------
// Denne procedure ser om der er kommet interrupt's, polling teknik
// --------------------------------------------------------
void polling_int(void)// Hvis Int0 er blevet aktiveret, udføres denne code.
{ // HusKat resette alle interrupt's
// Hvis INT0 er blevet aktiveret, udføres denne code.
if (int_0)
{
printf("\n Interrupt '0' er er blevet aktiveret, Hej med dig ");
int_0=FALSE; // reset boolean
}
// Hvis INT1 er blevet aktiveret, udføres denne code.
if (int_1)
{
printf("\n Interrupt '1' er er blevet aktiveret Hej Dan");
int_1=FALSE; // reset boolean
}
}
// --------------------------------------------------------
// ***************************************************
// ***** Her starter den hardware afhængige code *****
// ***************************************************
// --------------------------------------------------------
// --------------------------------------------------------
// ############## Ending ##################################
Ny bruger
Nybegynder
Opret
Preview
