oledwinch.c

一种深度和拉力测量系统

		for(j=0;j<64;j++){
			 dat = x;
			 LCDData1(dat);
			 LCDData2(dat);	
			}
		}
}
////
void OLED_Dis2(char c,int x,int y,int z)
{
//0<x<6,0<y<48,z为字符起始地址
char buf[32];
char comm,data;
int i,j,k,a;

if(c==0) {	a = 16; for(i=0;i<32;i++){ buf[i] = ziku[z+i]; }	}
if(c==1) {	a = 8;  for(i=0;i<16;i++){ buf[i] = zifu[z+i]; }	}

for(j=x;j<x+2;j++){
	comm=0xb8+j;
	LCDCMD2(comm);
	k=0;
	for(i=y;i<y+a;i++){
		comm=0x40+i;
		LCDCMD2(comm);
		data = buf[k];
		if(j==x+1) { data = buf[k+a]; }
		LCDData2(data); 
		k++;
		Nop();
		Nop();	
		Nop();	
	} 
  }
}
//////
void OLED_Dis1(char c,int x,int y,int z)
{
//0<x<6,0<y<48,z为字符起始地址
char buf[32];
char comm,data;
int i,j,k,a;

if(c==0) {	a = 16; for(i=0;i<32;i++){ buf[i] = ziku[z+i]; }	}
if(c==1) {	a = 8;  for(i=0;i<16;i++){ buf[i] = zifu[z+i]; }	}

for(j=x;j<x+2;j++){
	comm=0xb8+j;
	LCDCMD1(comm);
	k=0;
	for(i=y;i<y+a;i++){
		comm=0x40+i;
		LCDCMD1(comm);
		data = buf[k];
		if(j==x+1) { data = buf[k+a]; }
		LCDData1(data); 
		k++;
		Nop();
		Nop();	
		Nop();	
	} 
  }
}
/////
void Newlcd_init(void)
{
	char x;
	RST=0;
	RST=1;
	TRISD = 0x00;
	com = 0xc0;
	LCDCMD1(com);
	LCDCMD2(com);
	com = 0x3f;
	LCDCMD1(com);
	LCDCMD2(com);
}
void format(long l, unsigned char *buf, char d) 
{
	unsigned long r;
	unsigned char i, *s, n;
// sign	判断 l 的符号
	if (l < 0) {
	*buf++ = '-';  
	l = -l;
	}
	s = buf;
	n = 0;
// tail	
	for(i=0; i<d; i++) {
		n++;
		r = l % 10;
		*s++ = r + '0';
		l /= 10;;
	}
	*s++ = '.';
	n++;
// head
	if (l == 0) {
		n++;
		*s++ = '0';
	} 
	else {	
		while (l) {
			++n;
			r = l % 10;
			*s++ = r + '0';
			l /= 10;
		}
	}
// re-order	
	for(i=0; i<n/2; i++) {
		*(buf+n) = *(buf+i);
		*(buf+i) = *(buf+(n-i-1));
		*(buf+(n-i-1)) = *(buf+n);
	}
	*s=0x20;//后续为0但补足Space
Nop();
}
void DisNum(char p,unsigned char array[])
{
	int i,j,x;
//	int tempj;
	for(i=0;i<8;i++){
		j=i*8;	
		if(array[i]==0x2e)  x = 256;
		else if(array[i]==0x20)  x = 352;
		else if(array[i]==0x2d)  x = 368;
		else if(array[i]==0x38)  x = 128;
		else if(array[i]==0x39)  x = 144;
		else x = 16*array[i]; 
		Nop();
//        if(i<6){ j=j+16;	OLED_Dis1(1,p,j,x);}
		if(i<6){
      	  if(i<3){ j=40+8*i;	OLED_Dis2(1,p,j,x);}
		  else { j=8*(i-3);	OLED_Dis1(1,p,j,x);}
		}
 		x=0;
	}
}
void DisNum2(char p,unsigned char array[])
{
	int i,j,x;
//	int tempj;
	for(i=0;i<8;i++){
		j=i*8;	
		if(array[i]==0x2e)  x = 256;
		else if(array[i]==0x2d)  x = 368;
		else if(array[i]==0x38)  x = 128;
		else if(array[i]==0x39)  x = 144;
		else x = 16*array[i]; 
		Nop();
       if(i<6){ j=j+16;	OLED_Dis1(1,p,j,x);}
 		x=0;
	}
}
void DisComcMode(void)
{
//显示通讯模式
	OLED_Dis2(0,2,0,256);
	OLED_Dis2(0,2,16,288);
	OLED_Dis2(0,2,32,384);
	OLED_Dis2(0,2,48,416);
	OLED_Dis1(1,2,0,240);
	OLED_Dis1(1,2,8,240);
//	DisVersion();
}
void DisLogMode(void)
{
//显示记录模式
	OLED_Dis2(0,2,0,320);
	OLED_Dis2(0,2,16,352);
	OLED_Dis2(0,2,32,384);
	OLED_Dis2(0,2,48,416);
//	DisVersion();
}
void DisUnit(void)
{
//显示单位
//深度
	OLED_Dis2(0,0,0,0);
	OLED_Dis2(0,0,16,96);
//	displayzf2(0,32,80);
	OLED_Dis1(1,0,40,192);
//	displayzf2(0,48,96);
//速度
	OLED_Dis2(0,2,0,64);
	OLED_Dis2(0,2,16,96);
//	OLED_Dis1(1,2,32,176); //k
	OLED_Dis1(1,2,40,192);
	OLED_Dis1(1,2,48,224);
	OLED_Dis1(1,2,56,384);
//张力
	OLED_Dis2(0,4,0,128);
	OLED_Dis2(0,4,16,160);
	OLED_Dis1(1,4,40,208);
//差分
	OLED_Dis2(0,6,0,192);
	OLED_Dis2(0,6,16,224);
	OLED_Dis1(1,6,40,208);
}
///-------------------
///----CMD-----
///-------------------
void eeput(char adr, char val)
{
 	EEADRH = 0x00;
	EEADR = adr;
	EEDATA = val;

	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.WREN = 1;

	EECON2=0x55;
	EECON2=0xAA;
	EECON1bits.WR=1;
//	while(EECON1bits.WR==1);
	WaitEECON1WR();

	EECON1bits.WREN=0;
}
char eeget(char adr)
{
	EEADRH = 0x00;
	EEADR = adr;

	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.RD = 1;

    return EEDATA;
}
void cmdinit(void) {
	if(eeget(0) == 0x55 && eeget(1) == 0xaa) {
		for(i=0; i<18; i++) n.c[i] = eeget(0x10+i);
	}
	else {
		for(i=0; i<9; i++) n.i[i] = nini[i];
		for(i=0; i<18; i++) eeput(0x10+i, n.c[i]);
		eeput(0, 0x55);
		eeput(1, 0xaa);
	}
}

//=====================
//------7714
//=====================
void OpenSWSPI (void)
{
        SW_CS_PIN = 1;          // Make the CS pin high
        SW_DIN_PIN = 1;         // Make the DIN pin high

        SW_DOUT_PIN = 0;        // Make the Dout and SCK pin low
        SW_SCK_PIN = 0;

        TRIS_SW_CS_PIN = 0;     // Make the CS pin an output
        TRIS_SW_DIN_PIN = 1;    // Make the DIN pin an input
        TRIS_SW_DOUT_PIN = 0;   // Make the DOUT pin an output
        TRIS_SW_SCK_PIN = 0;    // Make the SCK pin an output
}
char WriteSWSPI(char output)
{
        char BitCount;                  // Bit counter
        static char input;

        BitCount = 8;                   // Do 8-bits
        input = output;

// SCK idles low
// Data output after falling edge of SCK
// Data sampled before rising edge of SCK

        do                              // Loop 8 times
        {
// at SCK Rising edge
                if(input&0x80)            // Set Dout to the next bit according to the MSB of data
                        SW_DOUT_PIN = 1;
				else
                        SW_DOUT_PIN = 0;

                SW_SCK_PIN = 1;         // Set the SCK pin

                Nop();                  // Produces a 50% duty cycle clock
                Nop();
                Nop();
                Nop();
// at SCK Falling edge
                if(SW_DIN_PIN)          // Set the carry bit according to the Din pin
                        STATUSbits.C = 1;
				else
                        STATUSbits.C = 0;

                SW_SCK_PIN = 0;         // Clear the SCK pin

                _asm
                rlcf  input,1,1
                _endasm

                BitCount--;             // Count iterations through loop
        } while(BitCount);

        return(input);                  // Return the received data
}

void initADC(void)
{
  OpenSWSPI();

  WriteSWSPI(0xff); // Reset SPI
  WriteSWSPI(0xff);
  WriteSWSPI(0xff);
  WriteSWSPI(0xff);

///64 A0 28 E4 A0 20
  WriteSWSPI(0x24); // High Filter
//  WriteSWSPI(0x21); /////////
  WriteSWSPI(0x20); /////////
//  WriteSWSPI(0x20); /////////

  WriteSWSPI(0x34); // Low Filter
//  WriteSWSPI(0x90); /////////////
//  WriteSWSPI(0x90); /////////////
  WriteSWSPI(0x8f); /////////////50Hz
}

void startADC(void)
{
  WriteSWSPI(0xff); // Reset SPI
  WriteSWSPI(0xff);
  WriteSWSPI(0xff);
  WriteSWSPI(0xff);

  WriteSWSPI(0x14); // mode reg
  WriteSWSPI(0x3c); // start Self-Cal, G=128
//  WriteSWSPI(0xfc); // start full-Cal, G=128
 }
char rdyADC(void)
{
	char mod, rdy;

//check modereg	
	WriteSWSPI(0x1c);
    mod = WriteSWSPI(0x00);

//query DRDY  
    WriteSWSPI(0x0c);
    rdy = WriteSWSPI(0x00);

	return  ((mod&0xe0)==0) && ((rdy&0x80)==0);
}
int getADC(void)
{
// union adr ad;
// read AD result
  WriteSWSPI(0x5c);
  ad.c[1]=WriteSWSPI(0x00);//<<<<------------------
  ad.c[0]=WriteSWSPI(0x00);//<<<<<<<---------------
 // if(ad.i<0) return (int)(ad.i);
  return (int)(ad.i-0x8000);
//  return (int)(ad.i-0x7AD3);
//  return (int)(0x8000-ad.i);
}

void ADonce(void)
{
        lcdnum = depth.u;
    	startADC();
//		while(!rdyADC());
		WaitrdyADC();

        force = getADC()+n.i[2];
}
//=====================
//------响应与应答
//=====================
void SCISendACK(char x)			// Send acknowledge
{
	Res1 = x;
	CSUM = 0x37;
	SCISend(0xff);
	SCISend(0xff);
	SCISend(0x37);							// Packet ID
	
	CSUM = (CSUM ^ Res1);						// acknowledge command
	SCISend(Res1);
	
	CSUM = (CSUM ^ Res2);						// acknowledge command
	SCISend(Res2);

	CSUM = (CSUM ^ 0x01);						// length
	SCISend(0x01);

	SCISend(CSUM);							// send checksum
	return;

}

void SCIGetPack(void)	// Get a data packet from host
{
 static unsigned char x;
  unsigned char i;
	do {
		do {
			Res1 = getch();			
		}while(Res1 != 0x37);

		Buf[2] = 0x37;					// get the start flag
		CSUM = 0x37;
		Buf[3] = getch();
		pcmd = Buf[3];				// get command
		CSUM = CSUM ^ Buf[3];
		Buf[4]=getch();
		lc = Buf[4];				// get length of data
		CSUM = CSUM ^ Buf[4];
		for(i=1;i<=lc;i++) {
			Buf[4+i] = getch();		// get data
			CSUM = CSUM ^ Buf[4+i];
		}
		x=getch();// get checksum
	} while(x!=CSUM);
//	return(pcmd);
}
void SCIDataInit(void)
{
   OpenTimer0(TIMER_INT_ON&T0_16BIT&T0_SOURCE_INT&T0_PS_1_8);
   OpenRB1INT (PORTB_CHANGE_INT_ON & PORTB_PULLUPS_ON & FALLING_EDGE_INT);
   OpenRB2INT (PORTB_CHANGE_INT_ON & PORTB_PULLUPS_ON & RISING_EDGE_INT);
   initADC();
   RCONbits.IPEN = 1;    
   INTCONbits.GIEH = 1; 
}
void SCIData(void)
{

char p1,p2,d1,d2,d3,d4;

    SCIDataInit();
	ADonce();

p1 = ad.c[1];		// PH
p2 = ad.c[0];		// PM
d3 = depth.c[3];		// PL
d2 = depth.c[2];		// TH
d1 = depth.c[1];		// TM
d0 = depth.c[0];		// TL

//--Response
	SCISend(0xff);
	SCISend(0xff);
	CSUM=0X37;
	SCISend(0x37);
	CSUM = CSUM ^ 0xb1;
	SCISend(0xb1);
	CSUM = CSUM ^ 0xb1;
	SCISend(0xb1);
	CSUM = CSUM ^ 0x07;
	SCISend(0x07);

//---Send temperature,press and timer
//张力
	CSUM = CSUM ^ p1;//ph
	SCISend(p1);//PH
	CSUM = CSUM ^ p2;//pm
	SCISend(p2);//PM
//深度
	CSUM = CSUM ^ d3;//pl
	SCISend(d3);//PL
	CSUM = CSUM ^ d2;	
	SCISend(d2);//TH
	CSUM = CSUM ^ d1;
	SCISend(d1);//TM
	CSUM = CSUM ^ d0;
	SCISend(d0);//TL

	SCISend(CSUM);

}
//=====================
//-----PC接口函数
//=====================
void SCIErase(void)			// Erase a block
{
	MEM_sector = (Buf[5] & 0x0f);
	MEM_block  =  Buf[6];
	MEM_page   = 0;

	MEM_EraseBlock(MEM_sector,MEM_block,MEM_page);
	SCISendACK(0xff);
}
//-------------------
void SCIFormat(void)
{
OLED_CLR(0x00);
//lcd_putrs((unsigned rom char *)"正在格式化...");
	OLED_Dis2(0,2,16,544);
	OLED_Dis2(0,2,32,576);
	OLED_Dis2(0,2,48,608);
	OLED_Dis1(0,2,0,640);
	OLED_Dis1(0,2,16,672);
	OLED_Dis1(1,2,32,256);
	OLED_Dis1(1,2,40,256);
	MEM_Format();
	SCISendACK(0xff);
OLED_CLR(0x00);
	OLED_Dis2(0,2,16,608);
	OLED_Dis2(0,2,32,640);
	OLED_Dis2(0,2,48,672);
	OLED_Dis1(0,2,0,704);
	OLED_Dis1(0,2,16,736);
//lcd_putrs((unsigned rom char *)"格式化成功...");
//	LightLED(20);
}
//----------------
void SCIRead(void)			// Read a line
{
  unsigned char i;  

	SCILoadAddr();
	MEM_ReadLine(MEM_sector,MEM_block,MEM_page,MEM_line);
	SCISend(0xff);
	SCISend(0xff);

	CSUM = 0x37;
	SCISend(0x37);								// Data ID

	CSUM = CSUM ^ Res1;
	SCISend(Res1);

	CSUM = CSUM ^ Res2;
	SCISend(Res2);

	CSUM = CSUM ^ 0x41;							// lengh of data (65 bytes)
	SCISend(0x41);
	for(i=0;i<=63;i++) {
		CSUM = CSUM ^ DataPack[i];
		SCISend(DataPack[i]);					// Send to host
	}
	SCISend(CSUM);								// send checksum
}
//--------------------
void SCIWrite(void)			// Write a line
{
   unsigned char i;
	ResetMem();
	SCILoadAddr();


	for(i=0;i<=63;i++) {
		DataPack[i] = Buf[i+11];
	}
	MEM_WriteLine(MEM_sector,MEM_block,MEM_page,MEM_line);
	SCISendACK(0xff);
}
//------------------------
void SCIBlock(void)			// Read a block
{
  unsigned char i,j,k;

	SCILoadAddr();
	CSUM = 0;

	for(i=0;i<=15;i++) {
		for(j=0;j<=7;j++) {
			MEM_ReadLine(MEM_sector,MEM_block,i,j);
			for(k=0;k<=63;k++) {
				CSUM = CSUM ^ DataPack[k];
				putch(DataPack[k]);			// send to host
			}
		}
	}

	putch(CSUM);
}
////--------------------------
void ShowAllParameter(void)
{
	char i;

	SCISend(0xff);
	SCISend(0xff);

	CSUM = 0x37;
	SCISend(0x37);								// Data ID

	CSUM = CSUM ^ 0xa1;
	SCISend(0xa1);

	CSUM = CSUM ^ 0x00;
	SCISend(0x00);

	CSUM = CSUM ^ 0x13;							// lengh of data (19 bytes)
	SCISend(0x13);

	if(eeget(0) == 0x55 && eeget(1) == 0xaa) 
	{
		for(i=0; i<18; i++) {
			n.c[i] = eeget(0x10+i);
			CSUM = CSUM ^ n.c[i];
			putch(n.c[i]);
		}
	}
	putch(CSUM);	
}
//-------------------------
void SetParameter(void)
{
	char i;

union tempx {
	char c[2];
	int i;
}trpx;

	i=Buf[5];
	trpx.c[0]=Buf[6];
	trpx.c[1]=Buf[7];
	if(trpx.i >= nmin[i] && trpx.i < nmax[i]) {
//				n.i[i] = x;
//				putrs1USART(sok);
				i <<= 1; 
				eeput(0x10+i, trpx.c[0]);
				i += 1;
				eeput(0x10+i, trpx.c[1]);

		SCISendACK(0xff);
		return;
			}

	else SCISendACK(0x55); /// 超出预置范围
}
///---------------------------
void ReadParameter(void)
{
	int i;
	char a1,a2;
	char sum;
	i=Buf[5];
	i <<= 1; 

	if(eeget(0) == 0x55 && eeget(1) == 0xaa) {
			 a1 = eeget(0x10+i);
			 a2 = eeget(0x10+i+1);
	}

	putch(0xff);
	putch(0xff);

	CSUM = 0x37;
	SCISend(0x37);

	CSUM = CSUM ^ 0xa1;
	SCISend(0xa1);

	CSUM = CSUM ^ 0x00;
	SCISend(0x00);	

	CSUM = CSUM ^ 0x03;
	SCISend(0x03);	

	CSUM = CSUM ^ a1;
	SCISend(a1);	

	CSUM = CSUM ^ a2;
	SCISend(a2);	

	SCISend(CSUM);		
}

///---------------------------
void InitDate(void)
{
	real_time.Year    = Buf[5];