etr232i.cpp

湖北水文黄石试点集中器代码

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright (C), 2005, Emtronix Tech. Co., Ltd.
* File name:       Etr232i.CPP
* Module name:     ETR232i模块的硬件接口函数
* Author/Date:     Emtronix  06/02/14 
* Version:         Ver 1.0
* Description:     ETR232i模块的硬件接口函数的.CPP文件
* Others:          如有改动，请在下面的历史记录登记，谢谢合作!

------------------History-----------------------------
* Modifier/Date:    //修订人及修订日期
* Modify Reason:    //修订原因
* Modification:     //修订的内容和位置的简要说明
------------------------------------------------------
* Modifier/Date:    //修订人及修订日期
* Modify Reason:    //修订原因
* Modification:     //修订的内容和位置的简要说明
------------------------------------------------------
 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <dos.h>
#include "etr232i.h"

#define		PIOMODE0	0xFF70
#define		PIODIR0		0xFF72
#define		PIODATA0	0xFF74
#define		PIOMODE1	0xFF76
#define		PIODIR1		0xFF78
#define		PIODATA1	0xFF7A

#define		WDTCTRL		0xFFE6

#define         TMR0CNT		0xFF50
#define		TMR0SIZE	0xF533
#define		MULTIPLIER	1143L
#define         MaxTick		0x1800beL

struct GPIOPos
{
   unsigned int RegIdx;
   unsigned int PosIdx;
};

struct GPIOPos Tab[8] = { { 0, 0 },  { 0, 10 }, { 0, 15 }, { 1, 9 },
			  { 1, 10 }, { 1, 11 }, { 1, 12 }, { 1, 13 } };

unsigned int DatBit[8] = { 0x0001, 0x0400, 0x8000, 0x0200,
			   0x0400, 0x0800, 0x1000, 0x2000 };

// current data register value:
unsigned int DatReg[2] = { 0, 0 };

unsigned int DataTab0[8] = { 0x0000, 0x0001, 0x0400, 0x0401,
			     0x8000, 0x8001, 0x8400, 0x8401 };

// Valid bits: Dir[0], Dir[1], ... Dir[7]
// Dir[i] = 0: output
// Dir[i] = 1: input (default setting)
unsigned char GPIODirCfg( unsigned char Dir )
{
   unsigned int i1, i2, i3;
   unsigned int DirReg[2], ModeReg[2];

   // get current setting:
   ModeReg[0] = inport( PIOMODE0 );
   DirReg[0] = inport( PIODIR0 );
   ModeReg[1] = inport( PIOMODE1 );
   DirReg[1]= inport( PIODIR1 );

   for( i1=0; i1<8; i1++ )
      {
      i2 = 1<<Tab[i1].PosIdx;
      i3 = 1<<i1;
      if( Dir&i3 )		// set as input
	 {
	 ModeReg[Tab[i1].RegIdx] &= ~i2;
	 DirReg[Tab[i1].RegIdx] |= i2;
	 }
      else			// set as output
	 {
	 ModeReg[Tab[i1].RegIdx] |= i2;
	 DirReg[Tab[i1].RegIdx] &= ~i2;
	 }
      }

   outport( PIOMODE0, ModeReg[0] );
   outport( PIODIR0, DirReg[0] );
   outport( PIOMODE1, ModeReg[1] );
   outport( PIODIR1, DirReg[1] );
   return 0;
}

// Valid bits: Value[0], Value[1], ... Value[7]
void  GPIOWrite( unsigned char Value )
{
   unsigned int  i1, i2;
   unsigned char ub1;

   disable( );

   DatReg[0] = DataTab0[Value&0x07];
   i2 = ((unsigned int)Value)&0x00f8;
   DatReg[1] = i2<<6;

   outport( PIODATA0, DatReg[0] );
   outport( PIODATA1, DatReg[1] );

   enable( );
}

// return input status
unsigned char GPIORead( )
{
   unsigned int  CurrDat[2];
   unsigned char ub1, ub2;

   // current value
   CurrDat[0] = inport( PIODATA0 );
   CurrDat[1] = inport( PIODATA1 );

   // processing lower 3-bit
   CurrDat[0] &= 0x8401;
   switch( CurrDat[0] )
      {
      case 0x0000: ub1 = 0; break;
      case 0x0001: ub1 = 1; break;
      case 0x0400: ub1 = 2; break;
      case 0x0401: ub1 = 3; break;
      case 0x8000: ub1 = 4; break;
      case 0x8001: ub1 = 5; break;
      case 0x8400: ub1 = 6; break;
      case 0x8401: ub1 = 7; break;
      }

   // processing higher 5-bit
   CurrDat[1] &= 0x3e00;
   ub2 = (unsigned char)(CurrDat[1]>>6);

   // combine together
   ub2 |= ub1;
   return ub2;

   /*
   unsigned int  i1, i2, i3, i4;
   // current value
   CurrDat[0] = inport( PIODATA0 ) & inport( PIODIR0 );
   CurrDat[1] = inport( PIODATA1 ) & inport( PIODIR1 );

   i4 = 0;
   for( i1=0; i1<3; i1++ )		// processing PIO0
	  {
	  i3 = 1<<i1;
	  if( CurrDat[0]&DatBit[i1] )  i4 |= i3;	// set as 1
	  else						   i4 &= ~i3;	// set as 0
	  }

   for( ; i1<8; i1++ )          // processing PIO1
	  {
	  i3 = 1<<i1;
	  if( CurrDat[1]&DatBit[i1] )  i4 |= i3;	// set as 1
	  else						   i4 &= ~i3;	// set as 0
	  }

   return (unsigned char)i4;
   */
}

// BitIdx = 0, 1, ...7
unsigned int GPIOSetBit( int BitIdx, int L10 )
{
   unsigned int  i1, i2;

   disable( );
   i2 = DatBit[BitIdx];
   if( BitIdx <= 2 )
      {
      if( L10 ) DatReg[0] |= i2;
      else      DatReg[0] &= ~i2;
      outport( PIODATA0, DatReg[0] );
      }
   else
      {
      if( L10 ) DatReg[1] |= i2;
      else      DatReg[1] &= ~i2;
      outport( PIODATA1, DatReg[1] );
      }
   enable( );

   return 0;
}

// L10 = 0, 1
void  GPRS_STB( int L10 )
{
   unsigned int  DatReg;

   disable( );
   // get current value
   DatReg = inport( PIODATA0 );

   if( L10 ) DatReg |= 0x2000;
   else      DatReg &= 0xdfff;

   outport( PIODATA0, DatReg );
   enable( );
}

// return = 0, 1
unsigned int GPRS_PWR( )
{
   unsigned int  DatReg;

   // get current value
   DatReg = inport( PIODATA0 ) & inport( PIODIR0 );

   if( DatReg&0x0008 ) return 1;
   return 0;
}

// L10 = 0, 1
void  GPRS_AUX( int L10 )
{
   if( L10 ) outportb( 0x23, 0x03 );
   else      outportb( 0x23, 0x01 );
}

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

   prev = inport( TMR0CNT );
   stop = prev + ((unsigned long)milliseconds * MULTIPLIER);

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

// timer1's input clock = 1MHz
int SetTMR1( unsigned int Divider )
{
   unsigned int ub1;

   ub1 = Divider / 2;
   outport( 0xff5a, ub1 );
   ub1 = Divider - ub1;
   outport( 0xff5c, ub1 );
   return 0;
}

void SysReboot( )
{
   disable( );
   outport( 0xff28, 0x07fd );        // mask all interrupts
   asm db	0xea
   asm dw	0xfff0
   asm dw	0xf000
}

////////////////////////////////////////////////////////
// watchdog duration time = 1exp2(ExpNum)/24.0MHz
// ExpNum = 0: disable WDT
// ExpNum = 25, 26: enable WDT
////////////////////////////////////////////////////////
int   SetWDT( int ExpNum )
{
   unsigned int WDTReg;

   switch( ExpNum )
      {
      case 25: WDTReg = 0xc040; break;          // enable WDT
      case 26: WDTReg = 0xc080; break;          // enable WDT
      default: WDTReg = 0;			// disable WDT
      }

   outport( WDTCTRL, 0x3333 );		// keyed sequence for writing
   outport( WDTCTRL, 0xCCCC );
   outport( WDTCTRL, WDTReg );

   outport( WDTCTRL, 0x5555 );		// keyed sequence for reading
   outport( WDTCTRL, 0xAAAA );
   if( inport(WDTCTRL)&0x8000 ) return 1;
   return 0;
}

int   ReloadWDT( )
{
//   outport( WDTCTRL, 0x3333 );		// keyed sequence for writing
//   outport( WDTCTRL, 0xCCCC );
//   outport( WDTCTRL, WDTReg );

   outport( WDTCTRL, 0x5555 );		// keyed sequence for reading
   outport( WDTCTRL, 0xAAAA );
   if( inport(WDTCTRL)&0x8000 ) return 1;
   return 0;
}

unsigned long NB_DayCnt = 0;
unsigned long NB_PrevTick = 0;

unsigned long NB_clock( )
{
   unsigned long currtick;

   disable( );
   currtick = *((unsigned long far*)(0x0040006Cl));
   enable( );

   if( currtick < NB_PrevTick ) NB_DayCnt += MaxTick;
   NB_PrevTick = currtick;

   currtick = NB_PrevTick + NB_DayCnt;
   return currtick;	//overflow happens after 2730 days since power on!!!
}

// input pri = 0:  => IRQ5 pri = 0; timer pri = 2, other unchanged
// input pri = 2:  => IRQ5 pri = 2; timer pri = 0, other unchanged
// input pri = 5:  => IRQ5 pri = 5; timer pri = 0, other unchanged (default)
void SetIRQ5Priority( int pri )
{
   switch( pri )
      {
      case 0:
           outport( 0xff3a, inport(0xff3a)&0xfff8 );
	   outport( 0xff32, (inport(0xff32)&0xfff8)|0x0002 );
	   break;
      case 2:
	   outport( 0xff3a, (inport(0xff3a)&0xfff8)|0x0002 );
	   outport( 0xff32, inport(0xff32)&0xfff8 );
	   break;
      case 5:		// restore default setting
	   outport( 0xff3a, (inport(0xff3a)&0xfff8)|0x0005 );
	   outport( 0xff32, inport(0xff32)&0xfff8 );
	   break;
      }
}