etr100.cpp

关于ETR100的设计

#include <stdio.h>
#include <dos.h>
#include <process.h>
#include "etr100.h"

#define		MULTIPLIER	2000L
#define		TMR0SIZE	62771L
#define         PWRCON          0xF800

#define P1PIN       0xF860
#define P1LTC       0xF862
#define P1DIR       0xF864
#define P1CFG       0xF820
#define P2PIN       0xF868
#define P2LTC       0xF86A
#define P2DIR       0xF86C
#define P2CFG       0xF822
#define P3PIN       0xF870
#define P3LTC       0xF872
#define P3DIR       0xF874
#define P3CFG       0xF824

#define WDTRLDH	    0xf4c0
#define WDTRLDL     0xf4c2
#define WDTCNTH	    0xf4c4
#define WDTCNTL     0xf4c6
#define WDTCLR      0xf4c8

#define TMR0DOS     0x0040
#define TMR1DOS     0x0041
#define TMR2DOS     0x0042
#define TMRCONDOS   0x0043

#define		CLKOUT		12.0e6     // for 24M ETR100
//#define		CLKOUT		24.0e6    // for 48M ETR100

void   EnableExtIO();
void   DisableExtIO();

static void near dummy (void) {};
unsigned int ReadTimer0( );

int SetCSAsIO( unsigned CSIndex, unsigned BasePort,
	       unsigned IOSize, unsigned WaitStates )
{
   union REGS regs;

   regs.h.ah = 0xe0;  /* set cursor position */
   if( CSIndex > 1 ) CSIndex = 1;
   regs.h.al = (unsigned char)CSIndex;
   regs.h.bl = 1;
   regs.x.dx = BasePort;
   switch( IOSize )
      {
      case 2:  regs.h.cl = 2;  break;
      case 4:  regs.h.cl = 4;  break;
      case 8:  regs.h.cl = 8;  break;
      case 16: regs.h.cl = 16; break;
      case 32: regs.h.cl = 32; break;
      case 64: regs.h.cl = 64; break;
      default: regs.h.cl = 2;
      }
   if( WaitStates > 31 ) regs.h.ch = 31;
   else                  regs.h.ch = WaitStates;

   int86( 0x15, &regs, &regs );

   if( regs.x.cflag == 0 ) return 0;
   else                    return -1;
}

// mode = 0: square; = 1: pulse
int SetTMR2( unsigned Divider )
{
   union REGS regs;

   regs.h.ah = 0xe1;
   regs.x.cx = Divider;
   int86( 0x15, &regs, &regs);

   if( regs.x.cflag == 0 ) return 0;
   else                    return -1;
}

void NB_Delay( unsigned int milliseconds )
{
   unsigned long stop;
   unsigned cur, prev;

   prev = ReadTimer0( );
   stop = prev + (milliseconds * MULTIPLIER);

   cur = ReadTimer0( );
   while( cur < stop )
      {
      if(cur < prev)     /* Check for timer wraparound */
	 {
	 if (stop < TMR0SIZE) break;
	 stop -= TMR0SIZE;
	 }
      prev = cur;
      cur = ReadTimer0( );
      }
}

unsigned int ReadTimer0( )
{
   asm pushf                    /* Save interrupt flag         */
   asm cli                      /* Disable interrupts          */
   asm mov  al,0h               /* Latch timer 0               */
   asm out  43h,al
       dummy();                 /* Waste some time             */
   asm in   al,40h              /* Counter --> bx              */
   asm mov  bl,al               /* LSB in BL                   */
       dummy();                 /* Waste some time */
   asm in   al,40h
   asm mov  bh,al               /* MSB in BH                   */
   asm mov  ax, 0f533h          /* */
   asm sub  ax, bx
   asm mov  bx, ax 	       /* Need ascending counter      */
   asm popf                     /* Restore interrupt flag      */
   return( _BX );
}

// Watchdog setup
int EnableWDT( float seconds )
{
   unsigned long value;
   unsigned int  LWord, HWord;

   value = (unsigned long)(seconds*CLKOUT);
   LWord = (unsigned int)(value&0xffff);
   HWord = (unsigned int)((value&0xffff0000l)>>16);

   EnableExtIO( );
   outport( WDTRLDH, HWord );
   outport( WDTRLDL, LWord );
   outport( WDTCLR, 0xf01e );
   outport( WDTCLR, 0xfe1 );
   DisableExtIO( );
   return 0;
}

//Watchdog reload
int ReloadWDT()
{
   EnableExtIO( );
   outport( WDTCLR, 0xf01e );
   outport( WDTCLR, 0xfe1 );
   DisableExtIO( );
   return 0;
}

//Watchdog get
unsigned long GetWDT()
{
   union REGS reg;
   unsigned long Get;

   reg.h.ah=0xe3;
   reg.h.al=2;
   int86(0x15, &reg, &reg);
   Get=reg.x.dx<<16+reg.x.cx;
   return Get;
}

void SysReboot( )
{
   //fcloseall( );
   _cexit( );
   asm db	0xea
   asm dw	0xfff0
   asm dw	0xf000
}

void EnableExtIO()
{
   asm {
      cli
      in  al, 23H
      mov ax, 8000H
      out 23H, al
      xchg al, ah
      out 22H, al
      out 22H, ax
      sti }
}

void DisableExtIO()
{
   asm {
      xor ax,ax
      out 0x23, al }
}

void EnterPowerSaveMode( )
{
   unsigned char IdleMode = 0x02;	//PowerdownMode=0x01;
   //unsigned char pmc;

   EnableExtIO();
   //pmc = inportb( PWRCON );
   outportb( PWRCON, IdleMode );
   //outportb( PWRCON, PowrdownMode );
   DisableExtIO();

   asm hlt
}


unsigned char GetDIN( )
{
   unsigned char DIN, BIT01, BIT3, BIT2;

   EnableExtIO();
   BIT01 = inportb( P3PIN )&0x03;
   DIN = inportb( P1PIN );
   BIT2 = (DIN&0x01)<<2;
   BIT3 = (DIN&0x04)<<1;
   DIN = BIT3|BIT2|BIT01;
   DisableExtIO();
   return DIN;
}

void PutDOUT( unsigned char abyte )
{
   unsigned char DOUT, DIR;

   DOUT = (abyte&0x1f)<<3;
   EnableExtIO();
   DIR = inportb( P1DIR )&0x7;
   outportb( P1LTC, DOUT|DIR );
   DisableExtIO();
}

// input parameter: BitIdx = 0, 1, 2, 3, 4
//                  L10 = 0, 1
void PutBitOUT( int BitIdx, int L10 )
{
   unsigned char DOUT, DIR, MaskBit;

   //DOUT = (abyte&0x1f)<<3;
   MaskBit = 8<<BitIdx;
   EnableExtIO();
   DIR = inportb( P1DIR )&0x7;
   DOUT = inportb( P1LTC );
   if( L10 ) DOUT |= MaskBit;
   else      DOUT &= ~MaskBit;
   outportb( P1LTC, DOUT|DIR );
   DisableExtIO();
}

void DisableKeypad( )
{
   disable( );
   outportb( 0x60, 0 );
   outportb( 0x61, 0 );
   enable( );
}

void EnableKeypad( )
{
   disable( );
   outportb( 0x60, 1 );
   outportb( 0x61, 1 );
   enable( );
}

int SetTMR0To1MS( )
{
  asm pushf                    /* Save interrupt flag         */
  asm cli                      /* Disable interrupts          */

 // input clk = 1.142857MHz(external clock)
  outportb( 0x43, 0x36 );     //load control reg for timer0
  outportb( 0x40, 0x75 );     //load count byte low
  outportb( 0x40, 0x04 );     //load count byte high   N=1141

  asm sti                      /* enable interrupts          */
  asm popf                     /* Restore interrupt flag      */
  return( _BX );
}

// tmr1clk = 1.142857MHz
int EnableTMR1Out( unsigned Divider )
{
   unsigned char ub1;

   DisableKeypad( );

   EnableExtIO();
   outportb( P3CFG, inportb(P3CFG)|0x02 );
   outportb( P3LTC, inportb(P3LTC)&0xfd );
   outportb( P3DIR, inportb(P3DIR)&0xfd );
   DisableExtIO();

   // set timer 1
   outportb( TMRCONDOS, 0x76 );			// timer1 mode 3
   outportb( TMR1DOS, Divider&0xff );		// set counter LOW byte
   outportb( TMR1DOS, (Divider>>8)&0xff );	//set counter HIGH byte

   return 0;
}