mywinchbeta.c

一种深度和拉力测量系统

//**********************************************************************************
//    File:              Mywinch.c for PPS66JC Depth Measure System
//    Written By:        YE ZHAOBO, R&D Center SPT.Inc. 2005.06	
//	  Last	Version 2005
//**********************************************************************************
// This code implements a PPS66JC surface interface box using the P18F6620 MCU;
// The code was compiled using the MC18 compliler ver. 8.01pl3;
// The device frequency should be 3.6864 MHz; 
// The PCB is PPS66JC
//
//关键更新信息
//...存贮功能
//...已经修正时间错误
//...realtime计时
//...用户自定义时钟
//...模式控制
//...采样控制
//...支持USB数据传输(Beta)
//-------------------------------------------------------------------
//-------------------------------------------------------------------
// The following files should be included in the MPLAB project:
//
//     mywinch.c      	   -- Main source code file
//	   winch.h
//                
// Use Bootloader tech
// Support Upgrade Online
// Support E-mail: [e-mail]
// All Right Reserved 
//---------------------------------------------------------------------

#include <p18f6620.h>        		// Register definitions

#include "winch.h"


///-------------
void high_routine (void); 
void low_routine (void); 
void InitPorts();
void ADCone(void);
void Sample(void);
void Version(void);
void Dectime(void);
void SampleInit(void);
void ADNow(void);
//---------------------------------------------------------------------
// Interrupt routine	中断处理程序
//---------------------------------------------------------------------
#pragma code high_ISR = 0x08
void high_ISR(void) 
{
_asm
	goto high_routine
_endasm
}
#pragma code  

#pragma code low_ISR=0x18
void low_ISR(void)
{
	_asm 
	goto low_routine
	_endasm 
}
#pragma code

#pragma interruptlow  low_routine save=PROD
void low_routine(void)
{	
//	INTCONbits.GIEL=1;
	if(PIR1bits.RCIF!=0){
	*in++=RCREG1;
	if((in-Buf)>=80) in=Buf;//超过缓冲则将指针复位(指向缓冲的第一个地址)
	}
} 
#pragma interrupt high_routine
void high_routine (void) 
{
	if(INTCON3bits.INT1IF) {
		if(PORTBbits.RB0)
			depth.u++;
		else 
			depth.u--;
		INTCON3bits.INT1IF = 0;
	}
	if(INTCONbits.TMR0IF) {
		d0 = d1;
		d1 = depth.u;
		speed = d1 - d0;
//		f0 = f1;
//		f1 = force;
//		delta = f1 - f0;
		TL++;
		if(TL==0x02){time.l++;TL=0;}
		INTCONbits.TMR0IF = 0;
	}
}
//---------------------------------------------------------------------
//           Functions
//---------------------------------------------------------------------

void Get_RealTimeClock(void);
void Init_RealTimeClock(void);

/**********************************************************************************/
void Get_RealTimeClock(void)
{

	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010000);				// Write DS1307:D0H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{
		WriteI2C(0x00);					// DS1307 : REG Addr.
		NotAckI2C();
	}
	IdleI2C();	
	StopI2C();
	while(SSPCON2bits.PEN);				// wait until stop condition is over

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

	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010001);				// Read DS1307:D1H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{
		real_time.Seconds = ReadI2C();
		AckI2C();
		while(SSPCON2bits.ACKEN);

		real_time.Minutes = ReadI2C();
		AckI2C();
		while(SSPCON2bits.ACKEN);

		real_time.Hours = ReadI2C();
		AckI2C();
		while(SSPCON2bits.ACKEN);

		real_time.Day = ReadI2C();
		AckI2C();
		while(SSPCON2bits.ACKEN);

		real_time.Date = ReadI2C();
		AckI2C();
		while(SSPCON2bits.ACKEN);

		real_time.Month = ReadI2C();
		AckI2C();
		while(SSPCON2bits.ACKEN);

		real_time.Year = ReadI2C();
		NotAckI2C();
		while(SSPCON2bits.ACKEN);
	}

	IdleI2C();	
	StopI2C();
		while(SSPCON2bits.PEN);				// wait until stop condition is over

}
/*------------------------------------------------------------------------------------*/
void Init_RealTimeClock(void)
{
	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010000);				// Write DS1307:D0H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{
		WriteI2C(0x00);					// DS1307 : REG Addr.
		NotAckI2C();

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Seconds);	// Configuration data  
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Minutes);	// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Hours);		// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Day);		// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Date);		// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Month);		// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Year);		// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.ctr_reg);	// Control REG
			NotAckI2C();
		}
	}

	IdleI2C();	
	StopI2C();
	while(SSPCON2bits.PEN);					// wait until stop condition is over

}
///
void Init_RealTime(void)
{
	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010000);				// Write DS1307:D0H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{
		WriteI2C(0x00);					// DS1307 : REG Addr.
		NotAckI2C();

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Seconds);	// Configuration data  
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Minutes);	// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Hours);		// Configuration data
			NotAckI2C();
		}
	}

	IdleI2C();	
	StopI2C();
	while(SSPCON2bits.PEN);					// wait until stop condition is over

}
void Init_RealDate(void)
{
	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010000);				// Write DS1307:D0H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{
		WriteI2C(0x04);					// DS1307 : REG Addr.
		NotAckI2C();

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Date);	// Configuration data  
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Month);	// Configuration data
			NotAckI2C();
		}

		IdleI2C();			
		if ( !SSPCON2bits.ACKSTAT )   	
		{
			WriteI2C(real_time.Year);		// Configuration data
			NotAckI2C();
		}
	}

	IdleI2C();	
	StopI2C();
	while(SSPCON2bits.PEN);					// wait until stop condition is over

}
////
char hextodec(unsigned char temp)
{
	unsigned char a,b,c;
	a=(temp&0xf0)>>4;
	b=(temp&0x0f);
	c=10*a+b;
	return c;
}

void Recorddepth(void)
{
	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010000);				// Write DS1307:D0H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{
		WriteI2C(0b00010000);					// DS1307 : REG Addr.0x10
		NotAckI2C();

		for(i=0;i<4;i++){
			IdleI2C();			
			if ( !SSPCON2bits.ACKSTAT ){
				WriteI2C(depth.c[i]);	// Configuration data  
				NotAckI2C();
			}
		}
	}

	IdleI2C();	
	StopI2C();
	while(SSPCON2bits.PEN);					// wait until stop condition is over

}

void Readrecord(void)
{
char e,i;

	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010000);				// Write DS1307:D0H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{
		WriteI2C(0b00010000);					// DS1307 : REG Addr.0x10
		NotAckI2C();
	}
	IdleI2C();	
	StopI2C();
	while(SSPCON2bits.PEN);				// wait until stop condition is over

Nop();
Nop();
///------------------------------------------------------------------------

	IdleI2C();
	StartI2C();
	while (SSPCON2bits.SEN);     		// wait until start condition is over 
	WriteI2C(0b11010001);				// Read DS1307:D1H
	NotAckI2C();

	IdleI2C();							// ensure module is idle
	if ( !SSPCON2bits.ACKSTAT )   		// test for ACK condition, if received
	{

	for(i=0;i<4;i++){
			depth.c[i] = ReadI2C();
			AckI2C();
			while(SSPCON2bits.ACKEN);
		}

			e = ReadI2C();
			AckI2C();
			while(SSPCON2bits.ACKEN);
	}

	IdleI2C();	
	StopI2C();
	while(SSPCON2bits.PEN);				// wait until stop condition is over
}

//-------------------------------------
//-------------串口接收与发送
//-------------------------------------
char getch(void)
{
	char c;
	while(in==out);//相等表示没有新数据进来
	c = *out;
	out++;
	if((out-Buf)>=80) out=Buf;
	return c;
}
void SCISend(char c)
{
	while(TXSTA1bits.TRMT==0);
	TXREG1=c;
}
void putch(char c)
{
	while(TXSTA1bits.TRMT==0);
	TXREG1=c;
}
void ResetMem(void)
{
//MEM
	MEM_CE=0;
	MEM_CLE=0;
	MEM_WE=1;
	MEM_ALE=0;
	MEM_RE=1;
}
//======================
//-----存储器代码-------
//======================
void SCILoadAddr(void)
{
	MEM_sector = (Buf[5] & 0x0f);
	MEM_block  =  Buf[6];
	MEM_page   =  Buf[7];
	MEM_line   =  Buf[8];
}
//--------------
void MEM_COMD(char command)
{
	TRISD=0X00;
	PORTD=0X00;
	MEM_CLE=0;
//command
	MEM_CLE=1;
	MEM_CE=0;
	MEM_ALE=0;
	MEM_WE=0;
	PORTD=command;
	MEM_WE=1;
	MEM_CLE=0;
	TRISD = 0xFF;
}
//----存储地址计算
void MEM_CalAddr(unsigned char sector_addr,
                 unsigned char block_addr,
                 unsigned char page_addr)
{
	second_addr = ((block_addr & 0x07)<<5) | page_addr;
	third_addr  = ((sector_addr & 0x07)<<5) | ((block_addr & 0xF8)>>3);
}

//--------------
void MEM_WeAddr(void)
{
//char first_addr,char second_addr,char third_addr
	TRISD=0X00;
	PORTD=0X00;
//address
	MEM_ALE=1;
	MEM_WE=0;
	PORTD=first_addr;
	MEM_WE=1;

	MEM_WE=0;
	PORTD= second_addr;
	MEM_WE=1;

	MEM_WE=0;	
	PORTD=third_addr;
	MEM_WE=1;
	MEM_ALE=0;

	Delay1TCY();
	Delay1TCY();
	Delay1TCY();
	Delay1TCY();
	Delay1TCY();
	Delay1TCY();
	Delay1TCY();
	Delay1TCY();
	Delay1TCY();
	Delay1TCY();			

	TRISD=0XFF;
}
//---------------------
unsigned char MEM_status(void)
{
	char stu;

	PORTE = 0xe6;
	TRISE = 0x00;				// Set port D as output

	MEM_DIR = 1;
	TRISD = 0x00;				// Set port D as output
	MEM_COMD(0x70);
	TRISD = 0x00;

	MEM_DIR = 0;
	TRISD = 0xFF;

	MEM_CE = 0;

	Delay1KTCYx(100);

	MEM_RE = 0;
	stu = PORTD;
	MEM_RE = 1;

	MEM_CE = 1;
	MEM_DIR = 1;
	return(stu);
}
//----------------------------------------------------------------------------------
void MEM_EraseBlock(unsigned char sector_addr,
                    unsigned char block_addr,
                    unsigned char page_addr)
{

	TRISD=0X00;
	MEM_CalAddr(sector_addr,block_addr,page_addr);
	MEM_COMD(0x60);					// Write a command(Erase)

	MEM_DIR = 1;
	TRISD = 0b00000000;

	MEM_ALE = 1;

	MEM_WE = 0;
	PORTD = second_addr;			// Write A9-A16
	MEM_WE = 1;

	MEM_WE = 0;
	PORTD = third_addr;				// Write A17-A21
	MEM_WE = 1;

	MEM_ALE = 0;

	MEM_COMD(0xd0);					// Erase start command

	while(!(0x40 & MEM_status()));	// status: bit6=1 ready

	MEM_CE = 1;
	MEM_DIR = 1;
	TRISD = 0b11111111;

}
//------------------------------------------------------------------------------------
void MEM_ReadLine(unsigned char sector_addr,
	          	  unsigned char block_addr,
                  unsigned char page_addr,
                  unsigned char line_addr)
{
     unsigned char i;

		MEM_CE = 0;					// chip1

	if(line_addr <4) {
		MEM_COMD(0x00);					// Read mode 0
		first_addr = line_addr;
	}
	else {
		MEM_COMD(0x01);					// Read mode 1
		first_addr = line_addr - 4;
	}