vfd.c

AirConditioner project

/*******************************************************/
/*                                                     */
/*  Author :  Jiayuan Wang                             */
/*                                                     */
/*  date/time: 30.Mar.2005                             */
/*                                                     */
/*  company:   CDHK, Tongji university                 */
/*                                                     */
/*  reviewed by:                                       */
/*                                                     */
/*  reviewed at:                                       */
/*******************************************************/

/***************edit by Jiayuan Wang, 2005.3.31********/
/***************edit by Jiayuan Wang, 2005.4.1 ********/
#include <hidef.h> /* for EnableInterrupts macro */
#include <MC68HC908GZ60.h> /* include peripheral declarations */
#include "COMMON.h"
#include "VFD.h"

/*  Global Variables */
UINT8 fandirection;
UINT8 vfd_num[10];                      //vfd num conversion table
UINT8 vfd_fan_ladder[8];                //fan speed conversion table
UINT8 leddata;
UINT8 fan_flag;

#pragma DATA_SEG MY_ZEROPAGE
volatile VFD_G1_G3 g1_hi;
volatile VFD_G1_G3 g1_lo;
volatile VFD_G1_G3 g2_hi;
volatile VFD_G1_G3 g2_lo;
volatile VFD_G1_G3 g3_hi;
volatile VFD_G1_G3 g3_lo;
volatile VFD_G4_LOW g4_lo;
volatile VFD_G4_HI g4_hi;
VFDKEY keyinput;
KEYFLAG keyflag;                        //key press down&up flag 
UINT8 settingtemp;                      //current set temp
UINT8 fanladder;                        //current fan speed
UINT8 dispCtrl;                         //display control command


/*****************************************************************************
 * Function:        HT16512_Init(void)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/ 
void HT16512_Init(void){
	
	UINT8 data;

	keyflag.key.s1=0;//0 not pressdown，1 pressdown
	keyflag.key.s2=0;
	keyflag.key.s3=0;
	keyflag.key.s4=0;
	keyflag.key.s5=0;
	keyflag.key.s6=0;
	keyflag.key.s7=0;
	keyflag.key.s8=0;
	keyflag.key.s9=0;
	keyflag.key.s10=0;
	keyflag.key.s11=0;
	keyflag.key.s12=0;
	
	settingtemp=20; //initial setting temp
	fanladder=1;		//initial fan speed
	fandirection=1; //initial fan direction
	dispCtrl=0x8f;  //max dimming
	
	
	//conversion table
	//number table
	vfd_num[0]=0x77;
	vfd_num[1]=0x12;
	vfd_num[2]=0x5d;
	vfd_num[3]=0x5b;
	vfd_num[4]=0x3a;
	vfd_num[5]=0x6b;
	vfd_num[6]=0x6f;
	vfd_num[7]=0x52;
	vfd_num[8]=0x7f;
	vfd_num[9]=0x7b;
	//fanspeed table
	vfd_fan_ladder[1]=0x00;
	vfd_fan_ladder[2]=0x20;
	vfd_fan_ladder[3]=0x30;
	vfd_fan_ladder[4]=0x38;
	vfd_fan_ladder[5]=0x3c;
	vfd_fan_ladder[6]=0x3e;
	vfd_fan_ladder[7]=0x3f;
	
	//initial VFD segment
	g1_lo.Byte=0x00;
	g1_hi.Byte=0x00;
	g2_lo.Byte=0x00;
	g2_hi.Byte=0x00;
	g3_lo.Byte=0xdd;
	g3_hi.Byte=0xf7;
	g4_lo.Byte=0x01;
	g4_hi.Byte=0xEF;
		
	SPSCK=0;
	CS16512=1;
	data=0x00;//display mode 4*16, command1
	CS16512=0;//cs up
	HoldTime();
	DataOut(data);
	HoldTime();
	CS16512=1;//cs down
	
	WriteVFD();//write all segment
	leddata=0x00;
	WriteLED();
}

/*****************************************************************************
 * Function:        DataOut(UINT8)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/
void DataOut(UINT8 data){
	
	UINT8 comp=0x01;						//to filter bits
	UINT8 datatemp=data;
	UINT8 counter=0;
	
  //from bit0 to bit7, bit by bit
	for(counter=8;counter>0;counter--){
		datatemp=data & comp;   //conserve current bit, other bits set to 0
		SPSCK=0;                //clock down
		if(datatemp==comp){			//if current bit==1 then out pin up
			MOSI=1;
			HoldTime();
			SPSCK=1;              //clock up
		}
		else{
			MOSI=0;								//else out pin down
			HoldTime();
			SPSCK=1;
		}
		HoldTime();
		comp=comp<<1;           //left shift 
	}
	
}

/*****************************************************************************
 * Function:        DataIn(void)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/

UINT8 DataIn(void){
	UINT8 comp=0x01;
	UINT8 counter=0;
	UINT8 value;		            //store received data
	
	value=0x00;
	
	//from bit0 to bit7, bit by bit
	for(counter=8;counter>0;counter--){
		value=value>>1;         //shift the last received bit to right
		SPSCK=1;                
		HoldTime();
		SPSCK=0;                
		if(MISO==1){
			value=value+0x80;			//add current bit to the MSB
		}
	}
return value;
}

/*****************************************************************************
 * Function:        ReadKey(void)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/
void ReadKey(void){	
	
	UINT8 data;
	
	//send read command
	data=0x46;//read key command
	CS16512=0;
	HoldTime();
	DataOut(data);
	
	//recieve data
	HoldTime();	//delay (to adjust)
	keyinput.byte1.col12=DataIn();
	HoldTime();
	keyinput.byte2.col34=DataIn();
	HoldTime();
	keyinput.byte3.col56=DataIn();
	HoldTime();
	CS16512=1;		//cs2 up
	
}

/*****************************************************************************
 * Function:        ProcessKey(void)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/
void ProcessKey(void){
		
	if(dispCtrl==0x8f){
		
		//temp process 15-30
		//temp up
		if(keyinput.byte1.Bits.s1==1 && settingtemp<30 && keyflag.key.s1==0){
			settingtemp++;
			g3_hi.MergedBits.Pnum=vfd_num[settingtemp%10];
			g3_lo.MergedBits.Pnum=vfd_num[settingtemp/10];
			keyflag.key.s1=1; //key pressdown
		}
		else if(keyinput.byte1.Bits.s1==0 && keyflag.key.s1==1){
			keyflag.key.s1=0;	 //key pressup
		}
		//temp down
		if(keyinput.byte1.Bits.s4==1 && settingtemp>15 && keyflag.key.s4==0){
			settingtemp--;
			g3_hi.MergedBits.Pnum=vfd_num[settingtemp%10];
			g3_lo.MergedBits.Pnum=vfd_num[settingtemp/10];
			keyflag.key.s4=1;
		}		
		else if(keyinput.byte1.Bits.s4==0 && keyflag.key.s4==1){
			keyflag.key.s4=0;
		}
			
	
		//fan speed process
		//fan speed up
		if(keyinput.byte1.Bits.s2==1 && fanladder<7 && keyflag.key.s2==0){
			fanladder++;
			g4_lo.MergedBits.Pnum=vfd_fan_ladder[fanladder];
			keyflag.key.s2=1;
			fan_flag = ON;
		}
		else if(keyinput.byte1.Bits.s2==0 && keyflag.key.s2==1){
			keyflag.key.s2=0;
		}
		//fan speed down
		if(keyinput.byte1.Bits.s5==1 && fanladder>1 && keyflag.key.s5==0){
			fanladder--;
			g4_lo.MergedBits.Pnum=vfd_fan_ladder[fanladder];
			keyflag.key.s5=1;
			fan_flag = OFF;
		}
		else if(keyinput.byte1.Bits.s5==0 && keyflag.key.s5==1 ){
			keyflag.key.s5=0;
		}
		
		
		//fan direction
		//head,body,leg
		if(keyinput.byte2.Bits.s3==1 && keyflag.key.s3==0)
		 { 
		  if(fandirection<4){
		    fandirection++;
		  } 
		  else if(fandirection>=4){
		    fandirection=1;
		  }
		  //g4_hi.Bits.f4=0;
		  g4_hi.Bits.f3=0;
		  g4_hi.Bits.f2=0;
		  switch(fandirection){
		    case 1:g4_hi.Bits.f2=1;g4_hi.Bits.f3=1;g4_lo.MergedBits.FROST=0;break;
		    case 2:g4_hi.Bits.f2=1;g4_lo.MergedBits.FROST=0;break;
		    case 3:g4_hi.Bits.f3=1;g4_lo.MergedBits.FROST=0;break;
		    case 4:g4_hi.Bits.f3=1;g4_lo.MergedBits.FROST=1;break;
		  }
			keyflag.key.s3=1;
		 }
		else if(keyinput.byte2.Bits.s3==0 && keyflag.key.s3==1){
			keyflag.key.s3=0;
		}
		/*
		//body
		if(keyinput.byte2.Bits.s6==1 && keyflag.key.s6==0){
			g4_hi.Bits.f3=~g4_hi.Bits.f3;
			keyflag.key.s6=1;
		}
		else if(keyinput.byte2.Bits.s6==0 && keyflag.key.s6==1){
			keyflag.key.s6=0;
		}
		//leg
		if(keyinput.byte2.Bits.s9==1 && keyflag.key.s9==0){
			g4_hi.Bits.f4=~g4_hi.Bits.f4;
			keyflag.key.s9=1;
		}
		else if(keyinput.byte2.Bits.s9==0 && keyflag.key.s9==1){
			keyflag.key.s9=0;
		}
		*/
		
		//heat or cool
		if(keyinput.byte1.Bits.s7==1 && keyflag.key.s7==0){
			g4_hi.Bits.COOL=~g4_hi.Bits.COOL;
			keyflag.key.s7=1;
		}
		else if(keyinput.byte1.Bits.s7==0 && keyflag.key.s7==1){
			keyflag.key.s7=0;
		}
		
		//frost
		/*
		if(keyinput.byte1.Bits.s8==1 && keyflag.key.s8==0){
			g4_lo.MergedBits.FROST=~g4_lo.MergedBits.FROST;
			keyflag.key.s8=1;
		}
		else if(keyinput.byte1.Bits.s8==0 && keyflag.key.s8==1){
			keyflag.key.s8=0;
		}
		*/
		//auto
		if(keyinput.byte1.Bits.s10==1 && keyflag.key.s10==0){
			g4_lo.MergedBits.AUTO=~g4_lo.MergedBits.AUTO;
			keyflag.key.s10=1;
		}
		else if(keyinput.byte1.Bits.s10==0 && keyflag.key.s10==1){
			keyflag.key.s10=0;
		}
		
		//setting temp
		if(keyinput.byte1.Bits.s11==1 && keyflag.key.s11==0){
			g3_hi.Bits.P7=~g3_hi.Bits.P7;
			keyflag.key.s11=1;
		}
		else if(keyinput.byte1.Bits.s11==0 && keyflag.key.s11==1){
			keyflag.key.s11=0;
		}
		
		//loop fan
		if(keyinput.byte2.Bits.s6==1 && keyflag.key.s6==0){
		  g4_hi.Bits.f4=~g4_hi.Bits.f4;
			g4_hi.Bits.LPFAN=~g4_hi.Bits.LPFAN;
			g4_hi.Bits.L1=~g4_hi.Bits.L1;
			keyflag.key.s6=1;
		}
		else if(keyinput.byte2.Bits.s6==0 && keyflag.key.s6==1){
			keyflag.key.s6=0;
		}
		
		//vfd off
		if(keyinput.byte2.Bits.s12==1 && keyflag.key.s12==0){
			dispCtrl=0x87;//xor to control the display on/off at bit3
			keyflag.key.s12=1;
		}
		else if(keyinput.byte2.Bits.s12==0 && keyflag.key.s12==1){
			keyflag.key.s12=0;
		}
		
	}
	else if(dispCtrl==0x87){
		
		//vfd on
		if(keyinput.byte2.Bits.s12==1 && keyflag.key.s12==0){
			dispCtrl=0x8f;//xor to control the display on/off at bit3
			keyflag.key.s12=1;
		}
		else if(keyinput.byte2.Bits.s12==0 && keyflag.key.s12==1){
			keyflag.key.s12=0;
		}
		
		
	}
}


/*****************************************************************************
 * Function:        WriteVFD(void)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/
void WriteVFD(void){
	//UINT8 i;
	UINT8 data;
	UINT8 senddata[8];
	UINT8 counter;
	
	//vfd data to array for convenience 
	senddata[0]=g1_lo.Byte;
	senddata[1]=g1_hi.Byte;
	senddata[2]=g2_lo.Byte;
	senddata[3]=g2_hi.Byte;
	senddata[4]=g3_lo.Byte;
	senddata[5]=g3_hi.Byte;
	senddata[6]=g4_lo.Byte;
	senddata[7]=g4_hi.Byte;
	
	data=0x40;//write VFD, increment address mode,  command2
	CS16512=0;
	HoldTime();
	DataOut(data);
	HoldTime();
	CS16512=1;
	
	data=0xC0;//initial address, command3
	CS16512=0;
	HoldTime();
	DataOut(data);
	
	for(counter=8;counter>0;counter--){//data
		data=senddata[8-counter];
		DataOut(data);
		HoldTime();
	}
	HoldTime();
	CS16512=1;
	
	data=dispCtrl;//dimming control
	CS16512=0;
	HoldTime();
	DataOut(data);
	HoldTime();
	CS16512=1;
	
}

/*****************************************************************************
 * Function:        WriteLED(void)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/
void WriteLED(void){
  UINT8 data;
	
	
	data=0b01000101;
	CS16512=0;
	HoldTime();
	DataOut(data);
	HoldTime();
	//CS16512=1;
	
	data=leddata;
	CS16512=0;
	HoldTime();
	DataOut(data);
	HoldTime();
  CS16512=1;
  
}

/*****************************************************************************
 * Function:        HoldTime(void)
 *
 * Description:     none
 *
 * Returns:         none
 *
 * Notes:           
 *
 *****************************************************************************/
void HoldTime(void){
	UINT8 counter=0x10;
	
	for(counter=0x10;counter>0x00;counter--);
}