t0isr.c

关于C8051无刷电机开发的源代码 自己调试过了 十分有用

//-----------------------------------------------------------------------------
// start7()
//-----------------------------------------------------------------------------
void start7(void)
{
   if (AccIndex > 191)                 // check if done accelerating
   {
      Status = RUN;                    // go to next state
      NextT = 16 * TSCALE;             // update next T
      AMX0P = 0x09;                    // config for motor current
      AMX0N = 0xFF;                    // single ended
      ADC0CN = 0x81;                   // initiate on T0 overflow
      TMR2CN|= 0x04;                   // enabe Timer 2 
      ET2 = 1;                         // Enable T2 interrupt
   }
}
//-----------------------------------------------------------------------------
// run()
//-----------------------------------------------------------------------------

void run(void)
{
   Tslot &= 0x03;                      // mask Tslot to 2 bits (modulo 4)
   switch(Tslot)                       // implement time slot manager
   {
      case 0:
         run0();                       // run time slot 0
         break;
      case 1:
         run1();                       // run time slot 1
         break;
      case 2:
         run2();                       // run time slot 2
         break;
      case 3:
         run3();                       // run time slot 3
         break;
   }
   Tslot++;                            // increment time slot
   Tslot &= 0x03;                      // mask Tslot to 2 bits (modulo 4)
}
//-----------------------------------------------------------------------------
// run0()
//-----------------------------------------------------------------------------
void run0(void)
{
   Imotor = avgCurrent();              // avg motor current using ADC
   if (Imotor > ILIMIT)                //
   {
      OverCurrent = 1;                 //
      AlignLED = ON;                   //
      Status = STOP;
   }
  AMX0P = 0x0E;                        // config for pot
  AMX0N = 0xFF;                        // single ended
  ADC0CN = 0xC0;                       // initiate on AD0BUSY, LPT
  ADC0CF |= 0x04;                      // left justify
  AD0INT = 0;                          // clear ADC0 end-of-conversion
  AD0BUSY = 1;                         // initiate conversion
  while (!AD0INT);                     // wait for conversion to complete
  Vpot = ADC0H;                        // read speed pot
  AMX0P = openPhase[MtrIndex];         // config for open phase
  AMX0N = 0x0D;                        // differential measurement
  ADC0CF &= ~0x04;                     // right justify
  ADC0CN = 0x81;                       // initiate on T0 overflow
}
//-----------------------------------------------------------------------------
// run1()
//-----------------------------------------------------------------------------
void run1(void)
{
   signed int v;
   v = avgVoltage();                   // read back EMF
   v = flip(v);                        // flip every other cycle
   Vmin = v;                           // save min voltage
   ADC0CN = 0x81;                      // initiate on T0 overflow
}
//-----------------------------------------------------------------------------
// run2()
//-----------------------------------------------------------------------------
void run2(void)
{
   signed int v;
   Vmid[MtrIndex] = avgVoltage();      // read avg voltage and store in array
   v = avgVmid() - Vmid[MtrIndex];     // subtract from avg midpoint
   v = flip(v);                        // flip every other cycle
   Verror = v;                         // store in global Verror
   ADC0CN = 0x81;                      // initiate on T0 overflow
}

//-----------------------------------------------------------------------------
// run3()
//-----------------------------------------------------------------------------
void run3(void)
{
   static unsigned char stable = 12;
   signed int v;
   v = avgVoltage();                   // read avg voltage
   v = flip(v);                        // flip every other cycle
   Vmax = v;                           // store max voltage
   Vdelta[MtrIndex]= Vmax - Vmin;      // calculate delta
   if(stable==0)                       // stabilization delay
   {
      Vemf = avgVdelta();              // calculate back EMF magnitude
      if(Vemf<VSTALL)                  // check for stall
      {
         Stall = 1;                    // set stall flag
         AlignLED = ON;                // blink LED
      }
      else
      {
         Stall = 0;                    // clear stall flag
         AlignLED = OFF;               // turn off LED
      }

   }
   else
   {
      stable--;                        // decrement stable delay
   }
   AMX0P = 0x09;                       // config for motor current
   AMX0N = 0xFF;                       // single ended
   ADC0CN = 0x81;                      // initiate on T0 overflow
}
//-----------------------------------------------------------------------------
// run4()
//-----------------------------------------------------------------------------
unsigned int avgCurrent(void)
{
   unsigned int sum, result;
   udblbyte v;

   unsigned char i ;

   sum = 0;
   while (!AD0INT);                    // wait for conversion to complete
   v.b.lo = ADC0L;                     // read ADC
   v.b.hi = ADC0H;
   sum += v.w;
   ADC0CN = 0x80;                      // initiate on AD0BUSY
   for (i = 7; i != 0; i--)            // repeat 7 more times
   {
      AD0INT = 0;                      // clear ADC0 end-of-conversion
      AD0BUSY = 1;                     // initiate conversion
      while (!AD0INT);                 // wait for conversion to complete
      v.b.lo = ADC0L;                  // read ADC
      v.b.hi = ADC0H;
      sum += v.w;                      // add to sum
   }
   result = sum>>2;
   return result;                      // return average reading
}

//-----------------------------------------------------------------------------
// flip()
//-----------------------------------------------------------------------------
signed int flip (signed int v)
{
   if ((MtrIndex & 0x01) == 0x00)      // flip on 0, 2, and 4
   {
      v = -v;
   }
   return v;
}
//-----------------------------------------------------------------------------
// avgVoltage()
//-----------------------------------------------------------------------------

signed int avgVoltage(void)
{
   signed int sum, result;
   sdblbyte v;

   unsigned char i ;

   sum = 0;
   while (!AD0INT);                    // wait for conversion to complete
   v.b.lo = ADC0L;                     // read ADC
   v.b.hi = ADC0H;
   sum += v.w;                         // add to sum
   ADC0CN = 0x80;                      // initiate on AD0BUSY
   for (i = 7; i != 0; i--)            // repeat 7 more times
   {
      AD0INT = 0;                      // clear ADC0 end-of-conversion
      AD0BUSY = 1;                     // initiate conversion
      while (!AD0INT);                 // wait for conversion to complete
      v.b.lo = ADC0L;                  // read ADC
      v.b.hi = ADC0H;
      sum += v.w;
   }
   result = sum>>2;                    // divide by 4,  11-bit effective
   return result;                      // return average reading
}
//-----------------------------------------------------------------------------
// avgVmid()
//-----------------------------------------------------------------------------
signed int avgVmid(void)
{
   signed int sum;
   unsigned char i;
   sum = 0;
   for (i = 0; i < 6; i++)             // repeat 6  times
   {
         sum += Vmid[i];               // calculate sum of midpoints
   }
   sum /=6;                            // divide by 6
   return sum;                         // return average
}
//-----------------------------------------------------------------------------
// avgVdelta()
//-----------------------------------------------------------------------------

 signed int avgVdelta(void)
 {
    signed int sum;
    unsigned char i;
    sum = 0;
    for (i = 0; i < 6; i++)            // repeat 6  times
    {
       sum += Vdelta[i];               // calculate sum of Vdelta
    }
    sum /=6;                           // divide by 6
    return sum;
}

//-----------------------------------------------------------------------------
// updateT()
//-----------------------------------------------------------------------------
void updateT (void)
{
   udblbyte t0;
   t0.b.lo = TL0;                      // get current value
   t0.b.hi = TH0;
   t0.w -= NextT;                      // subtract period
   TL0 = t0.b.lo;                      // save new overflow value
   TH0 = t0.b.hi;
}
//-----------------------------------------------------------------------------
// commutate()
//-----------------------------------------------------------------------------
void commutate (void)
{
   MtrIndex++;                         // increment MtrIndex
   if(MtrIndex>5)                      // fix if greater than 5
   {
      MtrIndex = 0;
   }
   P1       = 0xff;                    // P1 all high
   PCA0CPM0 = 0x00;                    // disable PWM
   PCA0CPM1 = 0x00;                    // disable PWM
   XBR1 &= ~0x40;                      // disable crossbar
   P1SKIP = skipPattern[MtrIndex];
   XBR1 |= 0x40;                       // enable crossbar
   PCA0CPM0 = 0x42;                    // enable 8-bit PWM mode
   PCA0CPM1 = 0x42;                    // enable 8-bit PWM mode


   if(MtrIndex==0)                     // toggle LED on zero
   {
      BlinkLED = ON;
   }
   else
   {
      BlinkLED = OFF;
   }

}