251.c

卡车仪表的单片机程序

 LCDDecoding();
 lcd_display(lcdshow,LCDContent,13);
 //motor turn to zero
 while(SpeedMotorSetting!=SpeedMotorCurrent)
 {
    if(MotorBlocked==0)
	  motor();
 }
										
 //Initiate timer1,adc,OPEN int0,1
 timer0_init();
 timer1_init();
 adc_init();
 GICR  = 0xC0;
 watchdog_init();
 //Initialization Finished!!! Insert your functional code here...
 while(1)
 {
    if(MotorBlocked==0)//unblocked by timer2
	  motor();
	if(ParallelBlocked==0)//unblocked by timer0
	  Parallel();
	if(CalculateBlocked==0)//unblocked by timer0
	  Calculate();
	if(MileageSaveBlocked==0)//unblocked by timer1_overflow
	  MileageSaving();
 }
}

//===============================================
//=============MOTOR SUBROUTINE=================
//================================================
void motor(void)
{
 	 uchar i;
 	 uchar clockwise = 0x00;//test
	 uchar anticlockwise = 0x00;
	 uchar ClockwiseCmd=0x00;//Original, reversed motor not inverted
	 uchar AnticlockwiseCmd=0x00;//Original, reversed motor not inverted

 //TEST
 PORTB ^= BIT(2);	 
	 //LIMITING
	 if(SpeedMotorSetting>MaxAngle)
	    SpeedMotorSetting = MaxAngle;
	 if(NMotorSetting>MaxAngle)
	    NMotorSetting = MaxAngle;		
	 
 	 //CALCULATE THE DIRECTION OF ALL MOTOR
	 if(SpeedMotorCurrent<SpeedMotorSetting)
	 {	 	 
	   SpeedMotorCurrent++;
	   ClockwiseCmd |=BIT(0);
	 }
	 else if (SpeedMotorCurrent>SpeedMotorSetting)
	 {
	   SpeedMotorCurrent--;
	   AnticlockwiseCmd |=BIT(0);
	 }
	 if(NMotorCurrent<NMotorSetting)
	 {
	   NMotorCurrent++;
	   ClockwiseCmd |=BIT(1); //SPEED invert
	 }
	 else if (NMotorCurrent>NMotorSetting)
	 {
	   NMotorCurrent--;
	   AnticlockwiseCmd |= BIT(1); //SPEED invert
	 }
	 for(i=0;i<=5;i++)
	 {
	   if(VoltageMotorCurrent[i]<VoltageMotorSetting[i])
	   {
	     VoltageMotorCurrent[i]++;
		 ClockwiseCmd |=BIT((i+VoltageMotorBias));
	   }
	   else if(VoltageMotorCurrent[i]>VoltageMotorSetting[i])
	   {
	     VoltageMotorCurrent[i]--;
		 AnticlockwiseCmd |=BIT((i+VoltageMotorBias));
	   }
	 }
	 //invert
	 clockwise |= ClockwiseCmd&ClockwiseMotor;
	 anticlockwise |= ClockwiseCmd&(~ClockwiseMotor);
	 anticlockwise |= AnticlockwiseCmd&(ClockwiseMotor);
	 clockwise |= AnticlockwiseCmd&(~ClockwiseMotor); 
	 
	 //CLOCKWISE 
	   //set DAD1(PB7)
	   PORTB |= BIT(7);
	   //set DAC1-8 through SPI
	   SPIOutput(clockwise);
 	   PORTB |= BIT(0);		 	//SET OUTCS
	   _NOP();
	   PORTB &= ~BIT(0);		//CLEAR OUTCS
	   //clear DAC1-8
	   SPIOutput(0);
	   PORTB |= BIT(0);		 	//SET OUTCS
	   _NOP();
	   PORTB &= ~BIT(0);		//CLEAR OUTCS

	 
	 //ANTICLOCKWISE
	   //clear DAD1(PB7)
	   PORTB &= ~BIT(7);
	   //set DAC1-8 through SPI
	   SPIOutput(anticlockwise);
	   PORTB |= BIT(0);		 	//SET OUTCS
	   _NOP();
	   PORTB &= ~BIT(0);		//CLEAR OUTCS	   
	   //clear DAC1-8
	   SPIOutput(0);
	   while ( !(SPSR & BIT(7)) )	;	  	//wait		 
	   PORTB |= BIT(0);		 	//SET OUTCS
	   _NOP();
	   PORTB &= ~BIT(0);		//CLEAR OUTCS	   

	 //BLOCK
	 MotorBlocked = 1;
	 
}

void Parallel(void)
{
  ParallelOutput();
  KeyMileageCurrentClear();//注意，小计清零的输入只能放在这里！！！
  ParallelBlocked = 1;
}


void ParallelOutput(void)
{
  SPIOutput( *((char*)&ParallelOutputCmd+1) );
  SPIOutput( *((char*)&ParallelOutputCmd+0) );
  PORTD |= BIT(7);
  _NOP();
  PORTD &= ~BIT(7);   
}

void LCDDecoding(void)//mileage,MileageCurrent --> LCDContent
{
 unsigned long temp1,temp2;
 uchar i;
 temp1 = mileage/10;
 //累计
 for(i=0;i<=6;i++)
 {
  temp2 = temp1/10;
  LCDContent[i] = temp1-temp2*10;
  temp1 = temp2;
  if(temp1 == 0 && i>=0) //保证1位不消隐
    break;
 }
 for(i++;i<=6;i++)
  LCDContent[i] = 10;//Hide
 //小计
 temp1 = MileageCurrent;
 for(i=0;i<=3;i++)
 {
  temp2 = temp1/10;
  LCDContent[12-i] = temp1-temp2*10;
  temp1 = temp2;
  if(temp1 == 0 && i>=1) //保证2位不消隐
    break;
 }
 for(i++;i<=3;i++)
  LCDContent[12-i] = 10;//Hide
 
 } 

void MileageSaving()
{
  EEPROM_write( 0x00, *((char*)&mileage+0) );
  EEPROM_write( 0x01, *((char*)&mileage+1) );
  EEPROM_write( 0x02, *((char*)&mileage+2) );
  EEPROM_write( 0x03, *((char*)&mileage+3) );
  EEPROM_write( 0x04, *((char*)&MileageCurrent+0) );
  EEPROM_write( 0x05, *((char*)&MileageCurrent+1) );
  EEPROM_write( 0x06, *((char*)&MileageCurrent+2) );
  EEPROM_write( 0x07, *((char*)&MileageCurrent+3) );
  MileageSaveBlocked = 1;
}
  
void MileageLoding()
{
  mileage = 0;
  MileageCurrent = 0;
  *((char*)&mileage+0) = EEPROM_read( 0x00 );
  *((char*)&mileage+1) = EEPROM_read( 0x01 );
  *((char*)&mileage+2) = EEPROM_read( 0x02 );
  *((char*)&mileage+3) = EEPROM_read( 0x03 );
  *((char*)&MileageCurrent+0) = EEPROM_read( 0x04 );
  *((char*)&MileageCurrent+1) = EEPROM_read( 0x05 );
  *((char*)&MileageCurrent+2) = EEPROM_read( 0x06 );
  *((char*)&MileageCurrent+3) = EEPROM_read( 0x07 );
  MileageSaveBlocked = 1;
}

void KeyMileageCurrentClear(void)
{
  int i;
  //1.PORTD7=Input+PullUp
  PORTD |= BIT(7); 
  for(i=0;i<100;i++)
   delay();
  DDRD &= ~BIT(7);
  for(i=0;i<100;i++)
   delay();
    //2. Read
  if (!(PIND & BIT(7)))
  {
    MileageCurrent = 0;
	mileage /=10;
	mileage *=10;
  }
  //3.PORTD7=Output0
  PORTD &=~BIT(7);
  DDRD |=BIT(7);
}

void AlarmCalculate(void)
{
  uchar i;
  if(VoltageRefreshed[0])
    if(Voltage[0]<ThresholdOil)
      ParallelOutputCmd |= BIT(AlarmLedOil);
	else
      ParallelOutputCmd &= ~BIT(AlarmLedOil);
  if(VoltageRefreshed[1])
    if(Voltage[1]<ThresholdTemp)
      ParallelOutputCmd |= BIT(AlarmLedTemp);
	else
      ParallelOutputCmd &= ~BIT(AlarmLedTemp);
  if(VoltageRefreshed[2])
    if(Voltage[2]<ThresholdOilP)
      ParallelOutputCmd |= BIT(AlarmLedOilP);
	else
      ParallelOutputCmd &= ~BIT(AlarmLedOilP);
  if(VoltageRefreshed[3])
    if(Voltage[3]<ThresholdAir)
      ParallelOutputCmd |= BIT(AlarmLedAir1);
	else
      ParallelOutputCmd &= ~BIT(AlarmLedAir1);
  if(VoltageRefreshed[4])
    if(Voltage[4]<ThresholdAir)
      ParallelOutputCmd |= BIT(AlarmLedAir2);
	else
      ParallelOutputCmd &= ~BIT(AlarmLedAir2);
  if(VoltageRefreshed[5])
    if(Voltage[5]<ThresholdVoltL)
      ParallelOutputCmd |= BIT(AlarmLedVoltL);
	else
      ParallelOutputCmd &= ~BIT(AlarmLedVoltL);
  if(VoltageRefreshed[5])
    if(Voltage[5]>ThresholdVoltH)
      ParallelOutputCmd |= BIT(AlarmLedVoltH);
	else
      ParallelOutputCmd &= ~BIT(AlarmLedVoltH);
  for(i=0;i<=3;i++)
  {
      if(TimeIntervalAvg<SpeedAlarm[i])
	    ParallelOutputCmd |= BIT(SpeedAlarmOut[i]);
	  else
	  	ParallelOutputCmd &= ~BIT(SpeedAlarmOut[i]);
  }
} 

//============================================================
//================Calculate Subroutine======================
//============================================================
void Calculate(void)
{
 unsigned long temp;
 uchar i;
 uchar j,k;
 uchar nt;
 
 unint volti;
 unint motoranglei;
 unint xb,xa,yb,ya;

 //==============Speed====================
 //1.Filter
 if(TimeIntervalRefreshed)
 {
   TimeIntervalAvg = (TimeIntervalAvg*(SpeedAvgSamples-1)+TimeInterval)/SpeedAvgSamples;
   TimeIntervalRefreshed = 0;
 }
 //2.Calculate Pointer Position
 temp = Timer1UnitMaxSpeed*MaxAngle;
 SpeedMotorSetting = temp/TimeIntervalAvg;

 //==============N=====================
 NPulseAvg = (NPulseAvg*(NAvgSamples-1)+NPulse)/NAvgSamples;
 temp = NPulseAvg;
 NMotorSetting = temp*MaxAngle/MaxNPulse;

 //=============Small Meter=======================
 for(i=0;i<=5;i++)
 { 
   //0. Averaging
   if(VoltageRefreshed[i])
   {
   	VoltageAvg[i] = (VoltageAvg[i]*(VoltageAvgSamples-1)+Voltage[i])/VoltageAvgSamples;
    VoltageRefreshed[i] = 0;
   }
   volti = VoltageAvg[i];
   nt = VoltageTableN[i];
   //1.Limiting
   if(volti<VoltageTable[i][0])
     volti = VoltageTable[i][0]; 
   if(volti>VoltageTable[i][nt])
     volti = VoltageTable[i][nt];
   //2.Look for which interval voltage is in. Sequential. 0..VotageTableN[i]]
   j=0;
   while(volti>VoltageTable[i][j+1] || volti<VoltageTable[i][j])
     j++;
   k=j;
   //3.Interpolate: y=(ya(xb-x)+yb(x-xa))(xb-xa)
   ya = MotorVoltageAngleTable[i][k];
   yb = MotorVoltageAngleTable[i][k+1];
   xa = VoltageTable[i][k];
   xb = VoltageTable[i][k+1];
   temp = ((unsigned long)ya)*(xb-volti);
   temp += ((unsigned long)yb)*(volti-xa);
   temp /= xb-xa;
   VoltageMotorSetting[i] = temp;
 }//for  

 //Mileage
 LCDDecoding();
 lcd_display(lcdshow,LCDContent,13);
 
 //Alarm
 AlarmCalculate();
 
 //BLOCK
 CalculateBlocked = 1;
}