📄 hsio_hl.bak
字号:
/****************************************************************/
/* */
/* Massage Machine Controler System */
/* */
/****************************************************************/
/* serial handler */
/****************************************************************/
#pragma interrupt INTST2 Hsout
#pragma interrupt INTSR2 Hsin
#pragma DI
#pragma EI
#pragma sfr
#pragma NOP
#include <stdio.h>
#include "hsio.H"
#define HIGH (bit)1
#define LOW (bit)0
#define ON (bit)1
#define OFF (bit)0
/****************************************************************/
/* prototype define */
/****************************************************************/
void Hrxb_chk( void ) ;
char *Hrxrd_adr( void ) ;
char *Hrxst_adr( void ) ;
char *Htxrd_adr( void ) ;
char *Htxst_adr( void ) ;
void Hgo_tx( void ) ;
void Hint_cts( void ) ;
void Hsout( void ) ;
void Hsin( void ) ;
/******************************************************************/
/** Hsio test program */
/** *****************************************************************/
/****************************************************************/
/* initialaize UART */
/****************************************************************/
/*Hsio_init((HSL1+HCL8+HPO), HBPS2400, Htx_buff, sizeof(Htx_buff)); */
/************ 0x28 , 0x13 , */
void Hsio_init(char asim, char brgc, char *adr, int size)
{
char brgc_work; /* asim: RART MODE;brgc: baud rate;*adr : tx data area(address)*/
/* size : the number of data bytes*/
register unsigned char dummy ;
if( TXE2 == 0 && RXE2 == 0)
{
CSIM2 = 0 ; /* 3 wire serial mode*/
ASIM2 = asim & 0xfc ; /*enable UART mode:1 stop bit,8 bit data,odd parity*/
BRGC2 = BRGC1_DATA; /* baud rate generator clock :fscc/16 0x70*/
/* SET TIMER1 FOR BAUD RATE CLOCK **/
TMC1 = TMC1_DATA; /*0x06*/
PRM1 = PRM1_DATA; /*0x02*/
CR10 = brgc;
/*2003-11-29 add priority*/
STPR21 = 0 ; /*highest priority */
STPR20 = 0 ; /*highest priority */
SRPR21 = 0;
SRPR20 = 0;
TCE1 = 1; /*start 8bit-timer count*/
dummy = RXB2 ;
Hsts = 0 ;
Htx_buffset(adr, size); /*Htx_btop point &adr*/
Hclear_tx();
Hclear_rx();
}
}
/****************************************************************/
/* 1st start tx */
/****************************************************************/
void Hgo_tx( void )
{
register char *next ;
if( (HENVTX_F == ON) && (HEXECTX_F == OFF) )
{
if( (int)(next = Htxrd_adr()) != EMPTY )
{
TXE2 = ON ;
HEXECTX_F = ON ;
TXS2 = *htx_rd ;
htx_rd = next ;
}
}
}
/****************************************************************/
/* send enable check */
/****************************************************************/
void Hint_cts( void )
{
if( HENVTX_F == OFF )
{
if( CTS == LOW )
{
Henable_tx() ;
Hgo_tx() ;
}
}
else
{
if( CTS == HIGH )
{
Hdisable_tx() ;
}
}
}
/****************************************************************/
/* interrupt process( send data) */
/****************************************************************/
void Hsout( void )
{
register char *next ;
EI(); //2003-12-24 add
if( (int)(next = Htxrd_adr()) != EMPTY )
{
if( HENVTX_F == ON )
{
HEXECTX_F = ON ;
TXS2 = *htx_rd ;
htx_rd = next ;
return ;
}
}
/* TXE1 = OFF ;*/
HEXECTX_F = OFF ;
}
/****************************************************************/
/* interrupt process( read data) */
/****************************************************************/
/*void Hsin( void )
{
register char *next ;
if( HENVRX_F == ON )
{
if( (int)(next = Hrxst_adr()) != FULL )
{
*(hrx_str + HRX_SIZE) = ASIS2 ;
*hrx_str = RXB2 ;
hrx_str = next ;
Hrxb_chk() ;
}
else
{
*(hrx_str + HRX_SIZE) = 0x8 ;
next=(char *)RXB2;
}
}
else
next = (char *)RXB2 ; /* dummy read */
//}
void Hsin( void )
{
unsigned char dummy_data;
unsigned char dummy_asis;
register char *next;
EI();
dummy_asis=ASIS2;
dummy_data=RXB2;
if( HENVRX_F == ON )
{
if( (int)(next = Hrxst_adr()) != FULL )
{
*(hrx_str + HRX_SIZE) = dummy_asis ;
*hrx_str = dummy_data ;
hrx_str = next ;
Hrxb_chk() ;
}
}
}
/****************************************************************/
/* receive buffer used rate check */
/****************************************************************/
void Hrxb_chk( void )
{
register int size ;
if( (size = (int)(hrx_str - hrx_rd)) < 0) /*rd before str 4_byte*/
size += HRX_SIZE ;
if( size > (int)(HRX_SIZE*0.8) )
RTS = HIGH ;
else
RTS = LOW ;
}
/****************************************************************/
/* disable rx */
/****************************************************************/
void Hdisable_rx( void )
{
RTS = HIGH ;
HENVRX_F = OFF ;
RXE2 = OFF ;
}
/****************************************************************/
/* enable rx */
/****************************************************************/
void Henable_rx( void )
{
HENVRX_F = ON ;
RXE2 = ON ;
Hrxb_chk() ;
}
/****************************************************************/
/* clear rx buff */
/****************************************************************/
void Hclear_rx( void ){
SRMK2 = ON ;
hrx_str = hrx_rd = (char *)Hrx_buff ;
SRMK2 = OFF ;
}
/****************************************************************/
/* rx buff check and calculate next read address */
/****************************************************************/
char *Hrxrd_adr( void )
{
if( hrx_rd == hrx_str )
return( (char *)EMPTY );
if( (long)hrx_rd == (long)((long)&Hrx_buff + HRX_SIZE - 1) )
return( (char *) Hrx_buff ) ;
else
return( hrx_rd + 1 ) ;
}
/****************************************************************/
/* rx buff check and calculate next store address */
/****************************************************************/
char *Hrxst_adr( void )
{
register char *next ;
next = hrx_str + 1 ;
if( next == (char *)((long)&Hrx_buff + HRX_SIZE) )
next = (char *) Hrx_buff ; /*???next=Hrx_buff ok?*/
if( next == hrx_rd )
return( (char *)FULL );
else
return( next ) ;
}
/****************************************************************/
/* disable tx */
/****************************************************************/
void Hdisable_tx( void )
{
HENVTX_F = OFF ;
if( HEXECTX_F == OFF )
TXE2 = OFF ;
}
/****************************************************************/
/* enable tx */
/****************************************************************/
void Henable_tx( void )
{
HENVTX_F = ON ;
TXE2 = ON ;
}
/****************************************************************/
/* set tx buffer address & size */
/****************************************************************/
void Htx_buffset( char *adr , int size )
{
htx_btop = adr ;
htx_bsize = size ;
}
/****************************************************************/
/* clear tx buff */
/****************************************************************/
void Hclear_tx( void )
{
STMK2 = ON ; /*disable interrupt*/
htx_str = htx_rd = htx_btop ;
STMK2 = OFF ; /*enable interrupt*/
}
/****************************************************************/
/* tx buff check and calculate next read address */
/****************************************************************/
char *Htxrd_adr( void )
{
if( htx_rd == htx_str )
return( (char *)EMPTY );
if( htx_rd == (char *)( (long)htx_btop + htx_bsize - 1) )
/* if( htx_rd == (htx_btop + htx_bsize - 1))*/
return( htx_btop ) ; /*if point end,then point top(pointer return)*/
else
return( htx_rd + 1 ) ;
}
/****************************************************************/
/* tx buff check and calculate next store address */
/****************************************************************/
char *Htxst_adr( void )
{
register char *next ;
next = htx_str + 1 ;
if( next == (htx_btop + htx_bsize) )
next = htx_btop ;
if( next == htx_rd )
return( (char *)FULL );
else
return( next ) ;
}
/****************************************************************/
/* tx data set */
/****************************************************************/
char Hput( char data )
{
register char *next ;
if( (int)(next = Htxst_adr()) != FULL )
{
STMK2 = ON ;
*htx_str = data ;
htx_str = next ;
Hgo_tx( ) ;
STMK2 = OFF ;
return( (char)NULL ) ;
}
return( FULL ) ;
}
/****************************************************************/
/* rx data read */
/****************************************************************/
int Hget( void )
{
register char *next ;
WRD_BYT data ;
if( (int)(next = Hrxrd_adr()) != EMPTY )
{
DI() ;
data.bt.l = *hrx_rd ;
data.bt.h = *(hrx_rd + HRX_SIZE) ;
hrx_rd = next ;
EI() ;
Hrxb_chk() ;
return( data.wd ) ;
}
else
return( EMPTY ) ;
}
/****************************************************************/
/* tx data puts tx_buff */
/****************************************************************/
void Hputs(char *s, int size)
{
register int count ;
count = size ;
while( count != 0 )
{
NOP();
if( Hput( *s ) == (char)NULL )
{
++s ;
--count ;
}
}
}
/****************************************************************/
/* rx data gets rx_buff */
/****************************************************************/
int Hgets(char *s)
{
register int count ;
WRD_BYT rx_dt ;
count = 0 ;
while( (rx_dt.wd = Hget( )) != -1)
{
NOP();
if( rx_dt.bt.h == 0 )
{
*s = rx_dt.bt.l ;
++s ;
++count ;
}
else if( count == 0 )
return( -1 ) ;
else
return( count ) ;
}
return( count ) ;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -