ab_t1.hpp

C学习课件

   AB_T1O1B::LOC( EXT );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
unsigned        AB_T1O1B::LOC      ( )
 {
   return( (AB_T1O1B::EXT==0x2F)? 0 : (AB_T1O1B::EXT-0x1F) );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
unsigned        AB_T1O1B::LOC      ( unsigned EXT )
 {
   AB_T1O1B::Err = 0;
   if( (1 > EXT) || (EXT > 4) ) {
      AB_T1O1B::EXT = 0x2F;
      AB_T1O1B::Err |= 0x100;
    } else if( AB_T1O1B::USED[EXT-1] ) {
      AB_T1O1B::EXT = 0x2F;
      AB_T1O1B::Err |= 0x100;
    } else if( AB_T1::C_ID( 0x1F+EXT ) != 0x0D ) {
      AB_T1O1B::EXT = 0x2F;
      AB_T1O1B::Err |= 0x100;
    } else {
      AB_T1O1B::USED[EXT-1] = 1;
      AB_T1O1B::EXT = 0x1F + EXT;
      AB_T1O1B::INIT();
    }

   return( AB_T1O1B::LOC() );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::INIT     ( )
 {
   AB_T1O1B::Err     =        0;
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL      ( unsigned MODE, unsigned int PIN )
 {
   union { unsigned int                DATA;
           struct { unsigned D0 : 4;
                    unsigned D1 : 4;
                    unsigned D2 : 4;
                    unsigned D3 : 4; } PART; } PIN_BUF;

   if( !AB_T1::Err[AB_T1::ID] )
    {
      PIN_BUF.DATA = PIN;

      AB_T1::S( AB_T1O1B::EXT );        // Select
      AB_T1::W( 0x6, PIN_BUF.PART.D3 ); // Write Data
      AB_T1::W( 0x5, PIN_BUF.PART.D2 );
      AB_T1::W( 0x4, PIN_BUF.PART.D1 );
      AB_T1::W( 0x3, PIN_BUF.PART.D0 );
      AB_T1::W( 0x2, MODE );            // Update
    }
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL      ( unsigned MODE )
 {
   if( !AB_T1::Err[AB_T1::ID] )
    {
      AB_T1::S( AB_T1O1B::EXT );        // Select
      AB_T1::W( 0x2, MODE );            // Update
    }
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL_SET  ( unsigned int PIN )
 {
   AB_T1O1B::CTL( 0x8, PIN );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL_SET  ( )
 {
   AB_T1O1B::CTL( 0x8 );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL_ON   ( unsigned int PIN )
 {
   AB_T1O1B::CTL( 0x4, PIN );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL_ON   ( )
 {
   AB_T1O1B::CTL( 0x4 );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL_OFF  ( unsigned int PIN )
 {
   AB_T1O1B::CTL( 0x2, PIN );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL_OFF  ( )
 {
   AB_T1O1B::CTL( 0x2 );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1O1B::CTL_REL  ( )
 {
   AB_T1O1B::CTL( 0x1 );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
unsigned int    AB_T1O1B::STU      ( )
 {
   union { unsigned int                DATA;
           struct { unsigned D0 : 4;
                    unsigned D1 : 4;
                    unsigned D2 : 4;
                    unsigned D3 : 4; } PART; } PIN_BUF;

   if( !AB_T1::Err[AB_T1::ID] )
    {
      AB_T1::S( AB_T1O1B::EXT );         // Select
      PIN_BUF.PART.D3 = AB_T1::R( 0xA ); // Read Data
      PIN_BUF.PART.D2 = AB_T1::R( 0x9 );
      PIN_BUF.PART.D1 = AB_T1::R( 0x8 );
      PIN_BUF.PART.D0 = AB_T1::R( 0x7 );
      return( PIN_BUF.DATA );
    }
   else
      return( 0x0000 );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
int             AB_T1O1B::ERR_NO   ( void )
 {
   return( AB_T1O1B::Err | AB_T1C1A::Err[AB_T1::ID] | AB_T1::Err[AB_T1::ID] );
 }

//=< AB_T1W1A >==============================================================//
//                                                                           //
//                                                                           //
//                                                                           //
//                                                                           //
//===========================================================================//

class AB_T1W1A :public AB_T1C1A {
   public:
                           AB_T1W1A  ( unsigned int P );
                           AB_T1W1A  ( unsigned int P, unsigned EXT );
      unsigned             LOC       ( );
      unsigned             LOC       ( unsigned EXT );
      void                 INIT      ( );
      int                  WHERE     ( );

      int                  VR_Adj    ( int I );
      void                 DA_Cal    ( );
      void                 STR_DA    ( float V );
      void                 END_DA    ( float V );

      float                STR_V     ( );
      float                END_V     ( );
      float                V         ( unsigned PIN );

      void                 SETUP     ( unsigned S_P, unsigned S_E, float S_V,
                                       unsigned E_P, unsigned E_E, float E_V,
                                       unsigned M  , unsigned B );
      void                 GO        ( );
      void                 STOP      ( );
      float                T_S       ( );
      float                T_mS      ( );
      float                T_uS      ( );
      int                  STR_D     ( );
      int                  END_D     ( );
      int                  STU_GO    ( );
      int                  STU_T     ( );
      int                  STU_R     ( );
      int                  STU_E     ( );
      int                  STU_O     ( );

      int                  ERR_NO    ( );

   private:
      void                 DA_12bit  ( int CH, unsigned int D );
      void                 AD_Path   ( unsigned N );

      void                 PAGE_TIM  ( );
      void                 PAGE_STR  ( );
      void                 PAGE_END  ( );

      static int           USED[4];
      unsigned             EXT;

      float                STR_DH;
      float                STR_DL;
      float                STR_AH;
      float                STR_AL;

      float                END_DH;
      float                END_DL;
      float                END_AH;
      float                END_AL;

      int                  Err;

 };

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
int             AB_T1W1A::USED[4] = { 0, 0, 0, 0 };
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
                AB_T1W1A::AB_T1W1A ( unsigned int P )
                         :AB_T1C1A ( P )
 {
   int      error=1;
   unsigned LOC_TMP=0x2F;

   for( unsigned S=0x20; !AB_T1::Err[AB_T1::ID] && (S<=0x23); S++ )
      if( AB_T1::C_ID(S) == 0x0E )
         if( LOC_TMP == 0x2F ) {
            LOC_TMP = S;
            error = 0;
         } else
            error = 1;

   AB_T1W1A::LOC( (error)?0:(LOC_TMP-0x1F) );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
                AB_T1W1A::AB_T1W1A ( unsigned int P, unsigned EXT )
                         :AB_T1C1A ( P )
 {
   AB_T1W1A::LOC( EXT );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
unsigned        AB_T1W1A::LOC      ( )
 {
   return( (AB_T1W1A::EXT==0x2F)? 0 : (AB_T1W1A::EXT-0x1F) );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
unsigned        AB_T1W1A::LOC      ( unsigned EXT )
 {
   AB_T1W1A::Err = 0;
   if( (1 > EXT) || (EXT > 4) ) {
      AB_T1W1A::EXT = 0x2F;
      AB_T1W1A::Err |= 0x100;
    } else if( AB_T1W1A::USED[EXT-1] ) {
      AB_T1W1A::EXT = 0x2F;
      AB_T1W1A::Err |= 0x100;
    } else if( AB_T1::C_ID( 0x1F+EXT ) != 0x0E ) {
      AB_T1W1A::EXT = 0x2F;
      AB_T1W1A::Err |= 0x100;
    } else {
      AB_T1W1A::USED[EXT-1] = 1;
      AB_T1W1A::EXT = 0x1F + EXT;
      AB_T1W1A::INIT();
    }

   return( AB_T1W1A::LOC() );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1W1A::INIT     ( )
 {
   if( !AB_T1W1A::ERR_NO() ) {
      AB_T1::S( AB_T1W1A::EXT );
      AB_T1W1A::PAGE_END( ); AB_T1::W( 0x4, 0x0 );
      AB_T1W1A::PAGE_STR( ); AB_T1::W( 0x4, 0x0 );
      AB_T1W1A::PAGE_TIM( );

      AB_T1W1A::STR_DH  =   3072.0;
      AB_T1W1A::STR_DL  =   1024.0;
      AB_T1W1A::STR_AH  =     10.0;
      AB_T1W1A::STR_AL  =      0.0;

      AB_T1W1A::END_DH  =   3072.0;
      AB_T1W1A::END_DL  =   1024.0;
      AB_T1W1A::END_AH  =     10.0;
      AB_T1W1A::END_AL  =      0.0;
    }
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
int             AB_T1W1A::WHERE    ( )
 {
   int      WHERE_TMP = 0;

   for( unsigned S=0x23; !AB_T1::Err[AB_T1::ID] && (S>=0x20); S-- ) {
      WHERE_TMP <<= 1;
      if( AB_T1::C_ID(S) == 0x0E )
         WHERE_TMP |= 1;
    }

   return( WHERE_TMP );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
int             AB_T1W1A::VR_Adj   ( int I )
 {
   int Diff = 0;

   if( !AB_T1W1A::ERR_NO() )
    {
      AB_T1::RST( );
      switch( I )
       {
         case 12:  AB_T1W1A::AD_Path( 0x2 );
                   AB_T1W1A::DA_12bit( 0, 0x0C00 ); delay(1);
                   Diff  = (int) AB_T1C1A::AD_12bit( );
                   AB_T1W1A::DA_12bit( 0, 0x0400 ); delay(1);
                   Diff -= (int) AB_T1C1A::AD_12bit( );
                   Diff -= (int) 0x0800;
	           break;
         case 13:  AB_T1W1A::AD_Path( 0x2 );
                   AB_T1W1A::DA_12bit( 0, 0x0400 ); delay(1);
                   Diff  = (int) AB_T1C1A::AD_12bit( );
                   Diff -= (int) 0x0400;
	           break;
         case 22:  AB_T1W1A::AD_Path( 0x1 );
                   AB_T1W1A::DA_12bit( 1, 0x0C00 ); delay(1);
                   Diff  = (int) AB_T1C1A::AD_12bit( );
                   AB_T1W1A::DA_12bit( 1, 0x0400 ); delay(1);
                   Diff -= (int) AB_T1C1A::AD_12bit( );
                   Diff -= (int) 0x0800;
	           break;
         case 23:  AB_T1W1A::AD_Path( 0x1 );
                   AB_T1W1A::DA_12bit( 1, 0x0400 ); delay(1);
                   Diff  = (int) AB_T1C1A::AD_12bit( );
                   Diff -= (int) 0x0400;
	           break;
         default : Diff = 0;

       }
      AB_T1::RST(  );
    }
   return ( Diff );
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1W1A::DA_Cal   ( )
 {
   float H, L;

   if( !AB_T1W1A::ERR_NO() )
    {
      AB_T1::RST( );

      AB_T1W1A::AD_Path( 0x2 );
      AB_T1W1A::DA_12bit( 0, 0x0C00 ); delay(10); AB_T1W1A::STR_AH = AB_T1C1A::AD();
      AB_T1W1A::DA_12bit( 0, 0x0400 ); delay(10); AB_T1W1A::STR_AL = AB_T1C1A::AD();

      AB_T1W1A::AD_Path( 0x1 );
      AB_T1W1A::DA_12bit( 1, 0x0C00 ); delay(10); AB_T1W1A::END_AH = AB_T1C1A::AD();
      AB_T1W1A::DA_12bit( 1, 0x0400 ); delay(10); AB_T1W1A::END_AL = AB_T1C1A::AD();

      AB_T1::RST( );
    }
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1W1A::STR_DA   ( float V )
 {
   unsigned int DA;

   if( !AB_T1W1A::ERR_NO() )
    {
      if( AB_T1W1A::STR_AH == AB_T1W1A::STR_AL ) AB_T1W1A::Err|= 0x200;
      if( !AB_T1W1A::Err ) {
         DA = (unsigned int) ( (((V-AB_T1W1A::STR_AL)*(AB_T1W1A::STR_DH-AB_T1W1A::STR_DL))/(AB_T1W1A::STR_AH-AB_T1W1A::STR_AL))+AB_T1W1A::STR_DL+0.5 );
         AB_T1W1A::DA_12bit( 0, DA );
       }
    }
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1W1A::END_DA   ( float V )
 {
   unsigned int DA;

   if( !AB_T1W1A::ERR_NO() )
    {
      if( AB_T1W1A::END_AH == AB_T1W1A::END_AL ) AB_T1W1A::Err |= 0x400;
      if( !AB_T1W1A::Err ) {
         DA = (unsigned int) ( (((V-AB_T1W1A::END_AL)*(AB_T1W1A::END_DH-AB_T1W1A::END_DL))/(AB_T1W1A::END_AH-AB_T1W1A::END_AL))+AB_T1W1A::END_DL+0.5 );
         AB_T1W1A::DA_12bit( 1, DA );
       }
    }
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
float           AB_T1W1A::STR_V    ( )
 {
   if( !AB_T1W1A::ERR_NO() )
    {
      AB_T1W1A::AD_Path( 0x2 ); delay(1);
      return( AB_T1C1A::AD( ) );
    }
   else
      return( 0.0 );
  }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
float           AB_T1W1A::END_V    ( )
 {
   if( !AB_T1W1A::ERR_NO() )
    {
      AB_T1W1A::AD_Path( 0x1 ); delay(1);
      return( AB_T1C1A::AD( ) );
    }
   else
      return( 0.0 );
  }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
float           AB_T1W1A::V    ( unsigned PIN )
 {
   PIN = ( (1 > PIN) || (PIN > 16) ) ? 0 : PIN - 1 ;
   if( !AB_T1W1A::ERR_NO() )
    {
      AB_T1W1A::STOP();

      AB_T1W1A::PAGE_STR();
      AB_T1::W( 0x3 , PIN );
      AB_T1::W( 0x4, ( AB_T1::R( 0x4 ) & 0x7 ) | 0x8 );
      AB_T1W1A::AD_Path( 0x8 ); delay(1);
      return( AB_T1C1A::AD( ) );
    }
   else
      return( 0.0 );
  }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void            AB_T1W1A::SETUP    ( unsigned S_P, unsigned S_E, float S_V,
                                     unsigned E_P, unsigned E_E, float E_V,
                                     unsigned M  , unsigned B )
 {
   unsigned STR_CND = 0;
   unsigned END_CND = 0;


   if( !AB_T1W1A::ERR_NO() ) {
      AB_T1W1A::STOP();

      AB_T1W1A::PAGE_TIM();
      if     ( B & 0x8 ) B = 0x8;
      else if( B & 0x4 ) B = 0x4;
      else if( B & 0x2 ) B = 0x2;
      else               B = 0x1;
      AB_T1::W( 0x4, B );

      AB_T1W1A::PAGE_STR();
      S_P = ( (1 > S_P) || (S_P > 16) ) ? 0 : S_P - 1 ;
      AB_T1::W( 0x3, S_P );
      if( S_E ) STR_CND |= 0x1;
      if( M   ) STR_CND |= 0x2;
      AB_T1::W( 0x4, STR_CND );
      AB_T1W1A::STR_DA( S_V );

      AB_T1W1A::PAGE_END();
      E_P = ( (1 > E_P) || (E_P > 16) ) ? 0 : E_P - 1 ;
      AB_T1::W( 0x3, E_P );
      if( E_E ) END_CND |= 0x1;
      AB_T1::W( 0x4, END_CND );
      AB_T1W1A::END_DA( E_V );

    }
 }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //