The 9th Blue Bridge Cup single chip microcomputer provincial competition

 

 

main.c

#include <STC15F2K60S2.H>
#include <IIC.H>

void Device_ctrl(unsigned  char p2date,unsigned char p0date )
{
	P0=p0date;
	P2=P2&0X1F|p2date;
	P2&=0X1F;
}

unsigned int ad_count;
unsigned char ad;
unsigned int pwm;
bit smg_flag;
unsigned  char set_mode=1;
unsigned int interval_time[5]={0,1200,1000,800,400};
unsigned char key_press;
unsigned char display_mode;
unsigned char read_ad(unsigned char add)
{
	   unsigned char date;
		 IIC_Start(); 
	   IIC_SendByte(0x90);
	   IIC_WaitAck();
	   IIC_SendByte(add);
	   IIC_WaitAck();
	
	   IIC_Start(); 
	   IIC_SendByte(0x91);
	   IIC_WaitAck();
	   date=IIC_RecByte();
	   IIC_SendAck(1);
		 IIC_Stop();
	
	   return date;
	   
}

void ad_process()
{
		if(ad_count>100)
		{
			ad_count=0;
			ad=read_ad(0x03);
			ad=ad/85+1;
			pwm=ad*2;
		}
}
unsigned char smg_display[8];
unsigned char smg_du[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
unsigned int smg_count;
unsigned char mode=1;
unsigned char index;
unsigned int interval=1000;
unsigned int time_count;
void smg_show()
{
		unsigned int i;
    Device_ctrl(0xc0,0);
	  Device_ctrl(0xe0,~smg_display[i]);
	  Device_ctrl(0xc0,0x01<<i);
	  i=(i+1)%8;
}

void smg_process()
{
		if(smg_count>3)
		{
				smg_count=0;
			  
			  if(display_mode==1)
				{
					if(key_press==1)
					{
						if(smg_flag)
						{
							smg_display[0]=smg_du[0];
							smg_display[1]=smg_du[set_mode];
							smg_display[2]=smg_du[0];
						}
						else
						{
							smg_display[0]=0x00;
							smg_display[1]=0x00;
							smg_display[2]=0x00;
						}
						smg_display[3]=0x00;
					 
						smg_display[4]=smg_du[interval_time[set_mode]/1000];
						smg_display[5]=smg_du[interval_time[set_mode]/100%10];
						smg_display[6]=smg_du[interval_time[set_mode]/10%10];
						smg_display[7]=smg_du[interval_time[set_mode]%10];
					}
					if(key_press==2)
					{
						  smg_display[0]=smg_du[0];
							smg_display[1]=smg_du[set_mode];
							smg_display[2]=smg_du[0];
						
						  smg_display[3]=0x00;
					  if(smg_flag)
						{
							smg_display[4]=smg_du[interval_time[set_mode]/1000];
							smg_display[5]=smg_du[interval_time[set_mode]/100%10];
							smg_display[6]=smg_du[interval_time[set_mode]/10%10];
							smg_display[7]=smg_du[interval_time[set_mode]%10];
						}
						else
						{
							smg_display[4]=0x00;
							smg_display[5]=0x00;
							smg_display[6]=0x00;
							smg_display[7]=0x00;
						}
					}
				}
			  if(display_mode==0)
				{
					smg_display[0]=0x00;
					smg_display[1]=0x00;
					smg_display[2]=0x00;
					smg_display[3]=0x00;
					
					smg_display[4]=0x00;
					smg_display[5]=0x00;
					smg_display[6]=0x00;
					smg_display[7]=0x00;
				}
				if(display_mode==2)
				{
					smg_display[0]=0x00;
					smg_display[1]=0x00;
					smg_display[2]=0x00;
					smg_display[3]=0x00;
					smg_display[4]=0x00;
					smg_display[5]=0x00;
					
					smg_display[6]=smg_du[ad/10];
					smg_display[7]=smg_du[ad%10];
				}
		}

}

unsigned char Trig_btn;
unsigned char Cont_btn;
unsigned int  key_count;
bit led_flag;
void key_btn()
{
		unsigned char readdate=P3^0xff;
	  Trig_btn=readdate&(Cont_btn^readdate);
	  Cont_btn=readdate;
}

void key_process()
{
		if(key_count>=10)
		{
				key_count=0;
			  key_btn();
			 
			  if(Trig_btn==0x08)//s4
				{
					if(display_mode==1)
					{
						if(key_press==1)
						{
							if(set_mode>1)
							{
							 set_mode--;
							}
						}
						if(key_press==2)
						 {
							if(interval>400)
							{
							  interval=interval-100;
								interval_time[set_mode]=interval;
							}
						 }
							
						}
					
					  if(display_mode==0)
						{
							display_mode=2;
						}
				}
			
				
				if(Trig_btn==0x04)//s5
				{
					if(display_mode==1)
					{
						if(key_press==1)
						{
							if(set_mode<4)
							{
								set_mode++;
							}
						}
						if(key_press==2)
						{
							if(interval<1200)
							{
								interval=interval+100;
								interval_time[set_mode]=interval;
							}
						}
							
				}
					
				}
				
				if(Trig_btn==0x02)//s6
				{
						display_mode=1;
					  key_press++;
					  if(key_press==3)
						{
							key_press=0;
							display_mode=0;
							interval_time[set_mode]=interval;
						}
					  
				}
				
				if(Trig_btn==0x01)//s7
				{
						led_flag=~led_flag;
					  index=0;
				}
				
				if(Trig_btn==0&Cont_btn==0)
				{
					if(display_mode==2)
					{
						display_mode=0;
					}
				}
		}
}
void Timer2Init()		//1 millisecond @12.000MHz
{
	AUXR &= 0xFB;		// Timer clock 12T Pattern 
	T2L = 0x18;		// Set initial value of timing 
	T2H = 0xFC;		// Set initial value of timing 
	AUXR |= 0x10;		// Timer 2 Start timing 
	IE2|=0X04;
	EA=1;
}

void main()
{
	  Timer2Init();
	  Device_ctrl(0x80,0xff);
	  Device_ctrl(0xa0,0x00);
		while(1)
		{
			smg_process();
			key_process();
			ad_process();
		}
}

unsigned int led_count;
unsigned int pwm_count;
void timer2service() interrupt 12
{
		smg_count++;
	  key_count++;
		smg_show();
	 
	  led_count++;
	  ad_count++;
	  pwm_count++;
	  time_count++;
	  if(time_count>800)
		{
				time_count=0;
			  smg_flag=~smg_flag;
		}
	  if(led_flag)
		{
			if(pwm_count<pwm)
			{
					if(mode==1)
					{
						P0=~(0x01<<index);P2=0X80;P2=0;
						if(led_count>interval_time[1])
						{
							led_count=0;
							index++;
						}
						if(index==8)
						{
							index=0;
							 mode=2;
						}
					
					}
					
					if(mode==2)
					{
						P0=~(0x80>>index);P2=0X80;P2=0;
						if(led_count>interval_time[2])
						{
							led_count=0;
							index++;
						}
						if(index==8)
						{
							index=0;
							 mode=3;
						}
					}
					
					if(mode==3)
					{
						P0=~((0x01<<index)|(0X80>>index));P2=0X80;P2=0;
						if(led_count>interval_time[3])
						{
							led_count=0;
							index++;
						}
						if(index==4)
							
						{
							
							 mode=4;
						}
					
					}
					
					if(mode==4)
					{
						P0=~((0x01<<index)|(0X80>>index));P2=0X80;P2=0;
						if(led_count>interval_time[4])
						{
							led_count=0;
							index++;
						}
						if(index==8)
						{
							 index=0;
							 mode=1;
						}
					
					}
			}
			else if(pwm_count<10)
			{
				P0=0XFF;P2=0X80;P2=0;
			}
			else
			{
				pwm_count=0;
			}
		}
	  
	  
}

iic.c

#include "iic.h"

#define DELAY_TIME 5

//I2C Bus internal delay function 
void IIC_Delay(unsigned char i)
{
    do{_nop_();}
    while(i--);        
}

//I2C Bus start signal 
void IIC_Start(void)
{
    SDA = 1;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 0;
    IIC_Delay(DELAY_TIME);
    SCL = 0;	
}

//I2C Bus stop signal 
void IIC_Stop(void)
{
    SDA = 0;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

// Send a reply or non reply signal 
void IIC_SendAck(bit ackbit)
{
    SCL = 0;
    SDA = ackbit;  					
    IIC_Delay(DELAY_TIME);
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SCL = 0; 
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

// Waiting for an answer 
bit IIC_WaitAck(void)
{
    bit ackbit;
	
    SCL  = 1;
    IIC_Delay(DELAY_TIME);
    ackbit = SDA;
    SCL = 0;
    IIC_Delay(DELAY_TIME);
    return ackbit;
}

//I2C The bus sends a byte of data 
void IIC_SendByte(unsigned char byt)
{
    unsigned char i;

    for(i=0; i<8; i++)
    {
        SCL  = 0;
        IIC_Delay(DELAY_TIME);
        if(byt & 0x80) SDA  = 1;
        else SDA  = 0;
        IIC_Delay(DELAY_TIME);
        SCL = 1;
        byt <<= 1;
        IIC_Delay(DELAY_TIME);
    }
    SCL  = 0;  
}

//I2C The bus receives a byte of data 
unsigned char IIC_RecByte(void)
{
    unsigned char i, da;
    for(i=0; i<8; i++)
    {   
    	SCL = 1;
	IIC_Delay(DELAY_TIME);
	da <<= 1;
	if(SDA) da |= 1;
	SCL = 0;
	IIC_Delay(DELAY_TIME);
    }
    return da;    
}

iic.h

#ifndef __IIC_H
#define __IIC_H

#include <STC15F2K60S2.H>

#include "intrins.h"

sbit SDA = P2^1;
sbit SCL = P2^0;

void IIC_Start(void); 
void IIC_Stop(void);  
bit IIC_WaitAck(void);  
void IIC_SendAck(bit ackbit); 
void IIC_SendByte(unsigned char byt); 
unsigned char IIC_RecByte(void); 

#endif