Код: Выделить всё
=====
//-----------------------------------------------------------------------------
// Blinky.c
//-----------------------------------------------------------------------------
// Copyright (C) 2010 德士康电子 Laboratories, Inc.
//
// AUTH: JS
// DATE: 11 JUL 3
//
// This program flashes the green LED on the C8051F31x target board about
// five times a second using the interrupt handler for Timer2.
//
// Target: C8051F31x
//
// Tool chain: KEIL Eval 'c'
//调光OK;
//开关OK;
//24c02ok;
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include <c8051f310.h> // SFR declarations
#include <INTRINS.H>
#include <stdio.h>
//------------------------
//-------------------------
sfr16 ADC0 = 0xbd; // ADC0 data
#define INT_DEC 256 // integrate and decimate ratio
long result;//ADC
//------------------------------------------------------------------------------------
// Global CONSTANTS
//------------------------------------------------------------------------------------
#define SYSCLK 24500000 // System clock frequency
#define SMB_FREQUENCY 50000 // Target SCL clock rate
#define WRITE 0x00 // SMBus WRITE command
#define READ 0x01 // SMBus READ command
// Device addresses (7 bits, lsb is a don't care)
#define EEPROM_ADDR 0xA0 // Device address for slave target
// Note: This address is specified
// in the Microchip 24LC02B
// datasheet.
// SMBus Buffer Size
#define SMB_BUFF_SIZE 0x08 // Defines the maximum number of bytes
// that can be sent or received in a
// single transfer
// Status vector - top 4 bits only
#define SMB_MTSTA 0xE0 // (MT) start transmitted
#define SMB_MTDB 0xC0 // (MT) data byte transmitted
#define SMB_MRDB 0x80 // (MR) data byte received
//------------------------------------------------------------------------------------
// Global VARIABLES
//------------------------------------24c02------------------------------------------------
unsigned char* pSMB_DATA_IN; // Global pointer for SMBus data
// All receive data is written here
unsigned char SMB_SINGLEBYTE_OUT; // Global holder for single byte writes
unsigned char* pSMB_DATA_OUT; // Global pointer for SMBus data.
// All transmit data is read from here
unsigned char SMB_DATA_LEN; // Global holder for number of bytes
// to send or receive in the current
// SMBus transfer
unsigned char WORD_ADDR; // Global holder for the EEPROM word
// address that will be accessed in
// the next transfer
unsigned char TARGET; // Target SMBus slave address
unsigned char temp_char;
unsigned char retval;
bit SMB_BUSY = 0; // Software flag to indicate when the
// EEPROM_ByteRead() or
// EEPROM_ByteWrite()
// functions have claimed the SMBus
bit SMB_RW; // Software flag to indicate the
// direction of the current transfer
bit SMB_SENDWORDADDR; // When set, this flag causes the ISR
// to send the 8-bit <WORD_ADDR>
// after sending the slave address
bit SMB_RANDOMREAD; // When set, this flag causes the ISR
// to send a START signal after
// sending the word address
bit SMB_ACKPOLL; // When set, this flag causes the ISR
// to send a repeated START until the
// slave has acknowledged its address
// 16-bit SFR declarations
sfr16 TMR2RL = 0xca; // Timer2 reload registers
sfr16 TMR2 = 0xcc; // Timer2 counter registers
sfr16 TMR3RL = 0x92; // Timer2 reload registers
sfr16 TMR3 = 0x94; // Timer3 counter registers
//-----------------------------------------------------------------------------
// 16-bit SFR Definitions for 'F30x
//-----------------------------------------------------------------------------
int temp_int;
int temp;
unsigned char k;
unsigned int m=200;
unsigned int LD;
unsigned char data1;
unsigned int set_PCA=2;//PCA
unsigned int Sign =0; //标记
unsigned int Sign_dispy =0; //标记
sbit LED = P3^3; // LED='1' means ON // P3.3 - LED
sbit LED1 = P0^7;
sbit key1 = P0^1;//(key_sw)
sbit key2 = P0^2;//(key_up)
sbit key3 = P0^3;//(key_down)2
sbit A3=P1^5;
sbit A2=P1^7;
sbit A1=P1^6;
//sbit A1=P1^5;
//sbit A2=P1^6;
//sbit A3=P1^7;
//------------ADC------------
///*0,1,2,3,4,5,6,7,8,9,*/
//unsigned char table1[]={0x50,0xDE,0x62,0x46,0xCC,0x45,0x41,0x5E,0x40,0x44,};
unsigned char table1[]={0xA0,0xBE,0xC2,0x8A,0x9C,0x89,0x81,0xBA,0x80,0x88,};
//-----------------------------------------------------------------------------
// Function PROTOTYPES
//-----------------------------------------------------------------------------
void SYSCLK_Init (void);
void PORT_Init (void);
void Timer2_Init (int counts);
void Timer2_ISR (void);
void delay(int time);
unsigned char key_in(void);
void on_off (void);
void pca_up(void);
void display(unsigned char num);
void delay1(unsigned int z);
//-------------------------------------24c02----------------------------------
void SMBus_Init (void);
void Timer1_Init (void);
void Timer3_Init (void);
void Port_Init (void);
void SMBus_ISR (void);
void Timer3_ISR (void);
void EEPROM_ByteWrite(unsigned char addr, unsigned char dat);
void EEPROM_WriteArray (unsigned char dest_addr, unsigned char *src_addr,
unsigned char len);
unsigned char EEPROM_ByteRead(unsigned char addr);
void EEPROM_ReadArray (unsigned char *dest_addr, unsigned char src_addr,
unsigned char len);
//-----------------------------------------------------------------------------
// SYSCLK_Init
//-----------------------------------------------------------------------------
//
// This routine initializes the system clock to use the internal 24.5MHz / 8
// oscillator as its clock source. Also enables missing clock detector reset.
//
void SYSCLK_Init (void)
{
}
//-----------------------------------------------------------------------------
// PORT_Init
//-----------------------------------------------------------------------------
//
// Configure the Crossbar and GPIO ports.
//
void PORT_Init (void)
{
// P3MDIN = 0xFD;
//------- 24c02-->p1.2_p1.3 ------
//------- PCA-->p1.4 -输出 ------
//P1MDOUT = 0xf0;
// P0SKIP = 0xFF;
// P1SKIP = 0xE3;
// XBR0 = 0x04;
// XBR1 = 0xc1;
//--------------------------
P3MDIN = 0xFD;
P1MDOUT = 0xF0;
P0SKIP = 0xFF;
P1SKIP = 0x03;
XBR0 = 0x04;
XBR1 = 0xC1;
}
//----------------------------
// ADC0配置，T3定时启动ADC
//----------------------------
void ADC0_Init (void)
{
//------------------------
REF0CN = 0x0e; // 启用内部基准源
//选择采样输入源GND作为负输入ADC工作在单端方式
//ADC0CN = 0xC5;
AMX0P = 0x11;
AMX0N = 0x1F;
ADC0CN = 0xC1; //控制器 0
EIE1 |= 0x08; // 启用 ADC 中断
}
//--------------------------------------------
// ----Timer0_Init----
//--------------------------------------------
void Timer0_Init()
{
TMOD = 0x21; // Mode set -timer 0, -timer 1, = 100001
TH0=0xF0; /* 计数初值写入TH1 */
TL0=0x00; /* 写入计数初值到TL1 */
ET0=1; /* 定时器0中断允许*/
TR0=1; //* 定时器0准备开始 *///Enable Timer 0 Interrupt.
}
//-----------------------------------------------------------------------------
// Timer2_Init
//-----------------------------------------------------------------------------
//
// Configure Timer2 to 16-bit auto-reload and generate an interrupt at
// interval specified by <counts> using SYSCLK/48 as its time base.
//
void Timer2_Init (int counts)
{
TMR2CN = 0x00; // Stop Timer2; Clear TF2;
// use SYSCLK/12 as timebase
CKCON &= ~0x60; // Timer2 clocked based on T2XCLK;
TMR2RL = -counts; // Init reload values
TMR2 = 0xffff; // set to reload immediately
ET2 = 1; // enable Timer2 interrupts
TR2 = 1; // start Timer2
}
//
//---------------------------------------
//
//---------------------------------------
void PCA_Init (void)
{
// PCA0CN = 0x40; // PCA0CN：PCA 控制寄存器 允许 PCA计数器/定时器。SFR地址：0xD8
// PCA0MD &= ~0x40;
// PCA0MD = 0x01; // PCA0MD：PCA 方式寄存器 当CF（PCA0CN.7）被置位时，允许PCA 计数器/定时器溢出的中断请求。
// PCA0CPM0 = 0x4b; // { PCA0CPMn：PCA 捕捉/比较寄存器 } MATn=1,PWMn=1,ECCFn=1,
PCA0CN = 0x40;
PCA0CPM0 = 0xc2;
PCA0CPL0 = 0x00;
PCA0CPH0 = 0x00;
PCA0CPL4 = 0x00;
PCA0MD &= 0x40;
PCA0MD = 0x01;
}
//-------------------
//
//-------------------
void delay(int time)
{
int a=time;
while(a!=0)
{
a--;
}
}
//------------------------
//
//-----------------------
void delay1(unsigned int z)
{
unsigned x,y;
for(x=z;x>0;x--)
for(y=114;y>0;y--);
} //z=1为1ms,z=100为100ms，
//------------------------
//
//-----------------------
unsigned char key_in(void)
{
if(key1==0) //(key_sw) key1=P0^2;
{
key1=1;
delay1(10);
if(key1==0)
{
key1=1;
delay1(10);
while(key1==0);
return(0x1);//返回字符"1"表示按键SW1按下
}
}
//--------------------------------------------------
if(key2==0) //(key_up)key2=P2^7;
{
key2=1;
delay1(10);
if(key2==0)
{
key2=1;
delay1(10);
while(key2==0);
if(key3==1)
{
return(0x3);//返回字符"2"表示按键SW1按下
}
return(0x2);//返回字符"2"表示按键SW1按下
}
}
return(0);//返回0,表示没有按键按下
}
//----------------------------------
//
//----------------------------------
void on_off (void) //
{
if(k==1) //(key_sw) key1=P0^2;
{ Sign = Sign+1;
if (Sign==1)// if/ else 选择结构
{
LED = 0;
}
else if(Sign==2)
{
LED = 1;
Sign= 0;
}
}
}
//-------------------------------------
//
//---------------------------------
void pca_up(void)
{
if(k==2)
{ Sign_dispy=500;
{if (Sign==1)// if/ else 选择结构
m=m-2;
for(;m>400;m=400); //显示匹配的问题
for(;m<200;m=200); //显示匹配的问题
// Write the value 0xCC to location 0x38 in the EEPROM
EEPROM_ByteWrite(0x27, m);
}
}
}
//--------------------
//
//----------------------
void pca_down(void)
{
if(k==3)
{ Sign_dispy=500;
{if (Sign==1)// if/ else 选择结构
m=m+2;
for(;m>400;m=400); //显示匹配的问题
for(;m<200;m=200); //显示匹配的问题
// Write the value 0xCC to location 0x38 in the EEPROM
EEPROM_ByteWrite(0x27, m);
}
}
}
//------------------------------------------------------------
//------------------------------
void display(unsigned int num)
{
unsigned int k,m,n,i;
k=num/1000;
m=(num%1000)/100;
n=(num%100)/10;
i=num%10;
if (Sign==1)// on_display
{
P2=table1[m];
A1=1;
delay1(3);
A1=0;
P2=0xff;
P2= table1[n];
A2=1;
delay1(3);
A2=0;
P2=0xff;
P2=table1[i];
A3=1;
delay1(3);
A3=0;
P2=0xff;
}
else if(Sign==2) // off_display
{
A1=0;
A2=0;
A3=0;
}
}
//----------------------24c02---------------
//-------------------------------------------
void EEPROM_ByteWrite( unsigned char eaddr, unsigned char edat )
{
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // Mark next transfer as a write
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 0; // Do not send a START signal after
// the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling (The ISR
// will automatically restart the
// transfer if the slave does not
// acknowledge its address.
// Specify the Outgoing Data
WORD_ADDR = eaddr; // Set the target address in the EEPROM's
// internal memory space
SMB_SINGLEBYTE_OUT = edat; // store dat (local variable) in a global
// variable so the ISR can read it after
// this function exits
pSMB_DATA_OUT = &SMB_SINGLEBYTE_OUT; // The outgoing data pointer points to
// the <dat> variable.
SMB_DATA_LEN = 1; // Specify to ISR that the next transfer
// will contain one data byte
// Initiate SMBus Transfer
STA = 1;
}
//------------------------------------------------------------------------------------
// EEPROM_WriteArray ()
//------------------------------------------------------------------------------------
// Writes <len> data bytes to the EEPROM slave specified by the <EEPROM_ADDR>
// constant.
//
void EEPROM_WriteArray (unsigned char dest_addr, unsigned char* src_addr,
unsigned char len)
{
unsigned char i;
unsigned char* pData = (unsigned char*) src_addr;
for( i = 0; i < len; i++ ){
EEPROM_ByteWrite(dest_addr++, *pData++);
}
}
//------------------------------------------------------------------------------------
// EEPROM_ByteRead ()
//------------------------------------------------------------------------------------
//
// This function returns a single byte from location <addr> in the EEPROM then
// polls the <SMB_BUSY> flag until the read is complete.
//
unsigned char EEPROM_ByteRead( unsigned char daddr)
{
unsigned char retval; // Holds the return value
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // A random read starts as a write
// then changes to a read after
// the repeated start is sent. The
// ISR handles this switchover if
// the <SMB_RANDOMREAD> bit is set.
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 1; // Send a START after the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling
// Specify the Incoming Data
WORD_ADDR = daddr; // Set the target address in the EEPROM's
// internal memory space
pSMB_DATA_IN = &retval; // The incoming data pointer points to
// the <retval> variable.
SMB_DATA_LEN = 1; // Specify to ISR that the next transfer
// will contain one data byte
// Initiate SMBus Transfer
STA = 1;
while(SMB_BUSY); // Wait until data is read
return retval;
}
///////////////
//------------------------------------------------------------------------------------
// EEPROM_ReadArray ()
//------------------------------------------------------------------------------------
// Reads up to 256 data bytes from the EEPROM slave specified by the <EEPROM_ADDR>
// constant.
//
void EEPROM_ReadArray (unsigned char* dest_addr, unsigned char src_addr,
unsigned char len)
{
while (SMB_BUSY); // Wait for SMBus to be free.
SMB_BUSY = 1; // Claim SMBus (set to busy)
// Set SMBus ISR parameters
TARGET = EEPROM_ADDR; // Set target slave address
SMB_RW = WRITE; // A random read starts as a write
// then changes to a read after
// the repeated start is sent. The
// ISR handles this switchover if
// the <SMB_RANDOMREAD> bit is set.
SMB_SENDWORDADDR = 1; // Send Word Address after Slave Address
SMB_RANDOMREAD = 1; // Send a START after the word address
SMB_ACKPOLL = 1; // Enable Acknowledge Polling
// Specify the Incoming Data
WORD_ADDR = src_addr; // Set the target address in the EEPROM's
// internal memory space
pSMB_DATA_IN = (unsigned char*) dest_addr;// Set the the incoming data pointer
SMB_DATA_LEN = len; // Specify to ISR that the next transfer
// will contain <len> data bytes
// Initiate SMBus Transfer
STA = 1;
while(SMB_BUSY); // Wait until data is read
}
//------------------------------------------------------------------------------------
// Initialization Routines
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
// SMBus_Init()
//------------------------------------------------------------------------------------
//
// SMBus configured as follows:
// - SMBus enabled
// - Slave mode disabled
// - Timer1 used as clock source. The resulting SCL frequency will be approximately
// 1/3 the Timer1 overflow rate
// - Setup and hold time extensions enabled
// - Free and SCL low timeout detection enabled
//
void SMBus_Init (void)
{
SMB0CF = 0x5D; // Use Timer1 overflows as SMBus clock
// source;
// Disable slave mode;
// Enable setup & hold time extensions;
// Enable SMBus Free timeout detect;
// Enable SCL low timeout detect;
SMB0CF |= 0x80; // Enable SMBus;
}
//------------------------------------------------------------------------------------
// Timer3_Init()
//------------------------------------------------------------------------------------
//
// Timer3 configured for use by the SMBus low timeout detect feature as follows:
// - Timer3 in 16-bit auto-reload mode
// - SYSCLK/12 as Timer3 clock source
// - Timer3 reload registers loaded for a 25ms overflow period
// - Timer3 pre-loaded to overflow after 25ms
// - Timer3 enabled
//
void Timer3_Init (void)
{
TMR3CN = 0x00; // Timer3 configured for 16-bit
// auto-reload,
// low-byte interrupt disabled
TMR3 = -(SYSCLK/12/40); // Timer3 configured to overflow after
TMR3RL = -(SYSCLK/12/40); // ~25ms (for SMBus low timeout detect)
CKCON &= ~0x40; // Timer3 uses SYSCLK/12
TMR3 |= 0x04; // Start Timer3
}
//------------------------------------------------------------------------------------
// Timer1_Init()
//------------------------------------------------------------------------------------
//
// Timer1 configured as the SMBus clock source as follows:
// - Timer1 in 8-bit auto-reload mode
// - SYSCLK / 12 as Timer1 clock source
// - Timer1 overflow rate => 3 * SMB_FREQUENCY
// - The maximum SCL clock rate will be ~1/3 the Timer1 overflow rate
// - Timer1 enabled
//
void Timer1_Init (void)
{
CKCON &= ~0x0B; // Timer1 clock source = SYSCLK / 12
TMOD = 0x20; // Timer1 in 8-bit auto-reload mode
TH1 = -(SYSCLK/SMB_FREQUENCY/12/3); // Timer1 configured to overflow at 1/3
// the rate defined by SMB_FREQUENCY
TL1 = -(SYSCLK/SMB_FREQUENCY/12/3); // Timer1 preloaded to overflow at 1/3
// the rate defined by SMB_FREQUENCY
TR1 = 1; // Timer1 enabled
}
//------------------------------------------------------------------------------------
// SMBus Interrupt Service Routine (ISR)
//------------------------------------------------------------------------------------
//
// SMBus ISR state machine
// - Master only implementation - no slave or arbitration states defined
// - All incoming data is written starting at the global pointer <pSMB_DATA_IN>
// - All outgoing data is read from the global pointer <pSMB_DATA_OUT>
//
void SMBus_ISR (void) interrupt 7
{
bit FAIL = 0; // Used by the ISR to flag failed
// transfers
static char i=0; // Used by the ISR to count the
// number of data bytes sent or
// received
static bit SEND_START = 0; // Send a start
switch (SMB0CN & 0xF0) // Status vector
{
// Master Transmitter/Receiver: START condition transmitted.
case SMB_MTSTA:
SMB0DAT = TARGET; // Load address of the target slave
SMB0DAT |= SMB_RW; // Load R/W bit
STA = 0; // Manually clear START bit
i = 0;
_nop_(); // reset data byte counter
break;
// Master Transmitter: Data byte (or Slave Address) transmitted
case SMB_MTDB:
if (ACK) // Slave Address or Data Byte
{ // Acknowledged?
if (SEND_START)
{
STA = 1;
SEND_START = 0;
break;
}
if(SMB_SENDWORDADDR) // Are we sending the word address?
{
SMB_SENDWORDADDR = 0; // Clear flag
SMB0DAT = WORD_ADDR; // send word address
if (SMB_RANDOMREAD)
{
SEND_START = 1; // send a START after the next ACK cycle
SMB_RW = READ;
}
break;
}
if (SMB_RW==WRITE) // Is this transfer a WRITE?
{
if (i < SMB_DATA_LEN) // Is there data to send?
{
SMB0DAT = *pSMB_DATA_OUT; // send data byte
pSMB_DATA_OUT++; // increment data out pointer
i++; // increment number of bytes sent
}
else
{
STO = 1; // set STO to terminte transfer
SMB_BUSY = 0; // clear software busy flag
}
}
else {} // If this transfer is a READ,
// then take no action. Slave
// address was transmitted. A
// separate 'case' is defined
// for data byte recieved.
}
else // If slave NACK,
{
if(SMB_ACKPOLL)
{
STA = 1;
// Restart transfer
}
else
{
FAIL = 1; // Indicate failed transfer
} // and handle at end of ISR
}
break;
// Master Receiver: byte received
case SMB_MRDB:
if ( i < SMB_DATA_LEN ) // Is there any data remaining?
{
*pSMB_DATA_IN = SMB0DAT; // Store received byte
pSMB_DATA_IN++; // Increment data in pointer
i++; // Increment number of bytes received
ACK = 1; // Set ACK bit (may be cleared later
// in the code)
}
if (i == SMB_DATA_LEN) // This is the last byte
{
SMB_BUSY = 0; // Free SMBus interface
ACK = 0; // Send NACK to indicate last byte
// of this transfer
STO = 1; // Send STOP to terminate transfer
}
break;
default:
FAIL = 1; // Indicate failed transfer
// and handle at end of ISR
break;
}
if (FAIL) // If the transfer failed,
{
SMB0CN &= ~0x40; // Reset communication
SMB0CN |= 0x40;
SMB_BUSY = 0; // Free SMBus
}
SI=0; // clear interrupt flag
}
//------------------------------------------------------------------------------------
// Timer3 Interrupt Service Routine (ISR)
//------------------------------------------------------------------------------------
//
// A Timer3 interrupt indicates an SMBus SCL low timeout.
// The SMBus is disabled and re-enabled here
//
void Timer3_ISR (void) interrupt 14
{
SMB0CN &= ~0x40; // Disable SMBus
SMB0CN |= 0x40; // Re-enable SMBus
TMR3CN &= ~0x80; // Clear Timer3 interrupt-pending flag
}
//===pca - adc======
unsigned int consequence( int temp,unsigned int m)
{
int tempera;
unsigned int setting_pca;
unsigned int consequence;
tempera=temp;
setting_pca=m;
if( tempera > setting_pca){consequence=255;} //关
else
{ consequence=8; } //开
if( tempera> 380){consequence=255;} //关
if( Sign==0){consequence=255;} //关
return consequence;
}
///-------------------------------------
//-------------------------------------
/*
int pid ( )
{
//---------
//定义变量
float Kp; //PI调节的比例常数
float Ti; //PI调节的积分常数
float T; //采样周期
float Ki;
float Kd;
float ek; //偏差e[k]
float ek1; //偏差e[k-1]
float ek2; //偏差e[k-2]
float uk; //u[k]
signed int uk1; //对u[k]四舍五入取整
Kp=200;
Ki=3/2;
ek=temp_int ;
ek1=200;
ek2=ek-ek1;
//Ti= (Ki*ek2)+( Kp*ek);
Ti= (Ki*ek2)+( Kp);
}
*/
//======
//
//------------------------------------------------------------
// MAIN Routine
//------------------------------------------------------------
void main (void)
{
// -----初始化-----
int iNum = 0;
int temperature;
char in_buff[8] = {0}; // incoming data buffer
char out_buff[8] = "ABCDEFG"; // outgoing data buffer
PCA0MD &= ~0x40; // WDTE = 0 (clear watchdog timer
// enable)
SYSCLK_Init (); // Initialize system clock to
// 24.5MHz
OSCICN |= 0x03; // Set internal oscillator to highest
// setting (24500000)
RSTSRC = 0x04; // enable missing clock detector
PORT_Init (); // initialize crossbar and GPIO
//-------ADC----------------
Timer0_Init();
ADC0_Init (); // init ADC
AD0TM=0;
//------PCA-------
Timer2_Init (6000); //5000-50000 //Init Timer2 to generate
// interrupts at a 10Hz rate.
PCA_Init (); /*PCA初始化成8位脉宽调置方式*/
//--------24co2--------------
Timer1_Init (); // Configure Timer1 for use as SMBus
// clock source
Timer3_Init (); // Configure Timer2 for use with SMBus
// low timeout detect
SMBus_Init (); // Configure and enable SMBus
//----------------------------
EIE1 = 0x99;
EIP1 = 0x01;
//（PCA0）中断允许
//----------------------------
EA = 1; // enable global interrupts
Sign =1;
// Write the value 0xAA to location 0x25 in the EEPROM
EEPROM_ByteWrite(0x26, 0x1);
// Read the value at location 0x25 in the EEPROM
temp_char = EEPROM_ByteRead(0x26);
// Store the outgoing data buffer at EEPROM address 0x50
EEPROM_WriteArray(0x50, out_buff, sizeof(out_buff));
// Fill the incoming data buffer with data starting at EEPROM address 0x50
EEPROM_ReadArray(in_buff, 0x50, sizeof(in_buff));
//--------------------------
// Read the value at location 0x25 in the EEPROM
temp_char = EEPROM_ByteRead(0x27);
m=temp_char;
//--------------------------
temp_char = EEPROM_ByteRead(0x27);
m=350;
//-----------------------------
while(result==0); //等于0,侧等待
while (1) {
EA =0;
// 关中断
temperature = result;
temperature &=0x000fff;
delay1(10);
EA = 1;
temperature = temperature*100L*3/512;
temp_int = temperature; //adc temp_int
temp =temp_int;
//temp =((temp_int-200)*200/100)+200;
set_PCA=consequence(temp, m);
//---------------------------------
data1=key_in();
k=data1;
on_off() ; //开关
pca_up(); //PCA加
pca_down(); //PCA减
//-----------------------------------
}
}
//////////////////////////////////////////////////////////////////
//
//------------------------------------------
// ---interrupt----
//---------Timer0_Overflow()---------------
void Timer0_Overflow() interrupt 1 using 0
{
TH0=0x80;
TL0=0x00;//计数初值到TL0 */
}
//-----------------------------------------------------------------------------
// Timer2_ISR
//-----------------------------------------------------------------------------
//
// This routine changes the state of the LED whenever Timer2 overflows.
//
void Timer2_ISR (void) interrupt 5
{
if (Sign_dispy >= 1) { display(m); Sign_dispy--; }
if (Sign_dispy<=1) { display( temp ); } //显示
TF2H = 0; // clear Timer2 interrupt flag
}
//------------------------------
// ADC0采样中断
//------------------------------
void ADC0_ISR (void) interrupt 10
{
static unsigned int_dec=INT_DEC;
static long accumulator=0L;
ADC0CN &= ~0x20; // 清 ADC 中断标志位
accumulator += ADC0; // 累加ADC采样数据
int_dec--; // 指针减1
if (int_dec == 0)
{ // 累加完了吗？
int_dec = INT_DEC; // 指针复位
result = accumulator>>8;
accumulator = 0L; // 累加和变量清0
}
}
//---------------------------------
// Interrupt Service Routines
//---------------------------------
//
void PCA_ISR (void) interrupt 11//PCA
{
unsigned char a ;
bit PWM_PAC;
CF = 0;
PCA0CPH0=set_PCA;
}
//================PCA==========
Ведь вещь-то действительно стоящая.
