Codestin Search App

(转锟斤拷锟斤拷STC-ISP.EXE V6.67锟斤拷锟斤拷)

使锟斤拷锟斤拷锟斤拷MCU锟斤拷STC15系锟叫碉拷片锟斤拷锟斤拷锟叫达拷锟斤拷ISP锟斤拷锟截撅拷锟斤拷(锟斤拷锟节匡拷锟斤拷锟斤拷STC锟斤拷isp锟斤拷锟斤拷协锟介）

使锟斤拷锟斤拷锟斤拷MCU锟斤拷STC15系锟叫碉拷片锟斤拷锟斤拷锟叫达拷锟斤拷ISP锟斤拷锟截撅拷锟斤拷(锟斤拷锟节匡拷锟斤拷锟斤拷STC锟斤拷片锟斤拷锟斤拷isp锟斤拷锟斤拷协锟介）

//锟斤拷示锟斤拷锟斤拷Keil锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷选锟斤拷Intel锟斤拷8058芯片锟酵号斤拷锟叫憋拷锟斤拷

//锟劫讹拷锟斤拷锟斤拷芯片锟侥癸拷锟斤拷频锟斤拷为11.0592MHz

//注锟斤拷:使锟矫憋拷锟斤拷锟斤拷锟絊TC15系锟叫的碉拷片锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时,锟斤拷锟斤拷要执锟斤拷锟斤拷Download锟斤拷锟斤拷之锟斤拷,

//锟斤拷锟杰革拷目锟斤拷芯片锟较碉拷,锟斤拷锟斤拷目锟斤拷芯片锟斤拷锟睫凤拷锟斤拷确锟斤拷锟斤拷

#include "reg51.h"

typedef bit BOOL;

typedef unsigned char BYTE;

typedef unsigned short WORD;

typedef unsigned long DWORD;

//锟疥、锟斤拷锟斤拷锟斤拷锟斤拷

#define FALSE 0

#define TRUE 1

#define LOBYTE(w) ((BYTE)(WORD)(w))

#define HIBYTE(w) ((BYTE)((WORD)(w) >> 8))

#define MINBAUD 2400L

#define MAXBAUD 115200L

#define FOSC 11059200L //锟斤拷锟斤拷芯片锟斤拷锟斤拷频锟斤拷

#define BR(n) (65536 - FOSC/4/(n)) //锟斤拷锟斤拷芯片锟斤拷锟节诧拷锟斤拷锟绞硷拷锟姐公式

#define T1MS (65536 - FOSC/1000) //锟斤拷锟斤拷芯片1ms锟斤拷时锟斤拷值

#define FUSER 24000000L //15系锟斤拷目锟斤拷芯片锟斤拷锟斤拷频锟斤拷

#define RL(n) (65536 - FUSER/4/(n)) //15系锟斤拷目锟斤拷芯片锟斤拷锟节诧拷锟斤拷锟绞硷拷锟姐公式

//SFR锟斤拷锟斤拷

sfr AUXR = 0x8e;

//锟斤拷锟斤拷锟斤拷锟斤拷

BOOL f1ms; //1ms锟斤拷志位

BOOL UartBusy; //锟斤拷锟节凤拷锟斤拷忙锟斤拷志位

BOOL UartReceived; //锟斤拷锟斤拷锟斤拷锟捷斤拷锟斤拷锟斤拷杀锟街疚�

BYTE UartRecvStep; //锟斤拷锟斤拷锟斤拷锟捷斤拷锟秸匡拷锟斤拷

BYTE TimeOut; //锟斤拷锟斤拷通讯锟斤拷时锟斤拷锟斤拷锟斤拷

BYTE xdata TxBuffer[256]; //锟斤拷锟斤拷锟斤拷锟捷凤拷锟酵伙拷锟斤拷锟斤拷

BYTE xdata RxBuffer[256]; //锟斤拷锟斤拷锟斤拷锟捷斤拷锟秸伙拷锟斤拷锟斤拷

char code DEMO[256]; //锟斤拷示锟斤拷锟斤拷锟斤拷锟斤拷

//锟斤拷锟斤拷锟斤拷锟斤拷

void Initial(void);

void DelayXms(WORD x);

BYTE UartSend(BYTE dat);

void CommInit(void);

void CommSend(BYTE size);

BOOL Download(BYTE *pdat, long size);

//锟斤拷锟斤拷锟斤拷锟斤拷锟�

void main(void)

{

while (1)

{

Initial();

if (Download(DEMO, 0x0100))

{

//锟斤拷锟截成癸拷

P3 = 0xff;

DelayXms(500);

P3 = 0x00;

DelayXms(500);

P3 = 0xff;

DelayXms(500);

P3 = 0x00;

DelayXms(500);

P3 = 0xff;

DelayXms(500);

P3 = 0x00;

DelayXms(500);

P3 = 0xff;

}

else

{

//锟斤拷锟斤拷失锟斤拷

P3 = 0xff;

DelayXms(500);

P3 = 0xf3;

DelayXms(500);

P3 = 0xff;

DelayXms(500);

P3 = 0xf3;

DelayXms(500);

P3 = 0xff;

DelayXms(500);

P3 = 0xf3;

DelayXms(500);

P3 = 0xff;

}

//1ms锟斤拷时锟斤拷锟叫断凤拷锟斤拷锟斤拷锟�

void tm0(void) interrupt 1 using 1

{

static BYTE Counter100;

f1ms = TRUE;

if (Counter100-- == 0)

{

Counter100 = 100;

if (TimeOut) TimeOut--;

}

//锟斤拷锟斤拷锟叫断凤拷锟斤拷锟斤拷锟�

void uart(void) interrupt 4 using 1

{

static WORD RecvSum;

static BYTE RecvIndex;

static BYTE RecvCount;

BYTE dat;

if (TI)

{

TI = 0;

UartBusy = FALSE;

}

if (RI)

{

RI = 0;

dat = SBUF;

switch (UartRecvStep)

{

case 1:

if (dat != 0xb9) goto L_CheckFirst;

UartRecvStep++;

break;

case 2:

if (dat != 0x68) goto L_CheckFirst;

UartRecvStep++;

break;

case 3:

if (dat != 0x00) goto L_CheckFirst;

UartRecvStep++;

break;

case 4:

RecvSum = 0x68 + dat;

RecvCount = dat - 6;

RecvIndex = 0;

UartRecvStep++;

break;

case 5:

RecvSum += dat;

RxBuffer[RecvIndex++] = dat;

if (RecvIndex == RecvCount) UartRecvStep++;

break;

case 6:

if (dat != HIBYTE(RecvSum)) goto L_CheckFirst;

UartRecvStep++;

break;

case 7:

if (dat != LOBYTE(RecvSum)) goto L_CheckFirst;

UartRecvStep++;

break;

case 8:

if (dat != 0x16) goto L_CheckFirst;

UartReceived = TRUE;

UartRecvStep++;

break;

L_CheckFirst:

case 0:

default:

CommInit();

UartRecvStep = (dat == 0x46 ? 1 : 0);

break;

}

//系统锟斤拷始锟斤拷

void Initial(void)

{

UartBusy = FALSE;

SCON = 0xd0; //锟斤拷锟斤拷锟斤拷锟斤拷模式锟斤拷锟斤拷为8位锟斤拷锟斤拷+1位偶锟斤拷锟斤拷

AUXR = 0xc0;

TMOD = 0x00;

TH0 = HIBYTE(T1MS);

TL0 = LOBYTE(T1MS);

TR0 = 1;

TH1 = HIBYTE(BR(MINBAUD));

TL1 = LOBYTE(BR(MINBAUD));

TR1 = 1;

ET0 = 1;

ES = 1;

EA = 1;

}

//Xms锟斤拷时锟斤拷锟斤拷

void DelayXms(WORD x)

{

f1ms = FALSE;

while (!f1ms);

} while (x--);

}

//锟斤拷锟斤拷锟斤拷锟捷凤拷锟酵筹拷锟斤拷

BYTE UartSend(BYTE dat)

{

while (UartBusy);

UartBusy = TRUE;

ACC = dat;

TB8 = P;

SBUF = ACC;

return dat;

}

//锟斤拷锟斤拷通讯锟斤拷始锟斤拷

void CommInit(void)

{

UartRecvStep = 0;

TimeOut = 20;

UartReceived = FALSE;

}

//锟斤拷锟酵达拷锟斤拷通讯锟斤拷锟捷帮拷

void CommSend(BYTE size)

{

WORD sum;

BYTE i;

UartSend(0x46);

UartSend(0xb9);

UartSend(0x6a);

UartSend(0x00);

sum = size + 6 + 0x6a;

UartSend(size + 6);

for (i=0; i

{

sum += UartSend(TxBuffer[i]);

}

UartSend(HIBYTE(sum));

UartSend(LOBYTE(sum));

UartSend(0x16);

while (UartBusy);

CommInit();

}

//锟斤拷STC15系锟叫碉拷芯片锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟截筹拷锟斤拷

BOOL Download(BYTE *pdat, long size)

{

BYTE arg;

BYTE cnt;

WORD addr;

//锟斤拷锟斤拷

CommInit();

while (1)

{

if (UartRecvStep == 0)

{

UartSend(0x7f);

DelayXms(10);

}

if (UartReceived)

{

arg = RxBuffer[4];

if (RxBuffer[0] == 0x50) break;

return FALSE;

}

//锟斤拷锟矫诧拷锟斤拷

TxBuffer[0] = 0x01;

TxBuffer[1] = arg;

TxBuffer[2] = 0x40;

TxBuffer[3] = HIBYTE(RL(MAXBAUD));

TxBuffer[4] = LOBYTE(RL(MAXBAUD));

TxBuffer[5] = 0x00;

TxBuffer[6] = 0x00;

TxBuffer[7] = 0xc3;

CommSend(8);

while (1)

{

if (TimeOut == 0) return FALSE;

if (UartReceived)

{

if (RxBuffer[0] == 0x01) break;

return FALSE;

}

//准锟斤拷

TH1 = HIBYTE(BR(MAXBAUD));

TL1 = LOBYTE(BR(MAXBAUD));

DelayXms(10);

TxBuffer[0] = 0x05;

CommSend(1);

while (1)

{

if (TimeOut == 0) return FALSE;

if (UartReceived)

{

if (RxBuffer[0] == 0x05) break;

return FALSE;

}

//锟斤拷锟斤拷

DelayXms(10);

TxBuffer[0] = 0x03;

TxBuffer[1] = 0x00;

CommSend(2);

TimeOut = 100;

while (1)

{

if (TimeOut == 0) return FALSE;

if (UartReceived)

{

if (RxBuffer[0] == 0x03) break;

return FALSE;

}

//写锟矫伙拷锟斤拷锟斤拷

DelayXms(10);

addr = 0;

TxBuffer[0] = 0x22;

while (addr < size)

{

TxBuffer[1] = HIBYTE(addr);

TxBuffer[2] = LOBYTE(addr);

cnt = 0;

while (addr < size)

{

TxBuffer[cnt+3] = pdat[addr];

addr++;

cnt++;

if (cnt >= 128) break;

}

CommSend(cnt + 3);

while (1)

{

if (TimeOut == 0) return FALSE;

if (UartReceived)

{

if ((RxBuffer[0] == 0x02) && (RxBuffer[1] == 'T')) break;

return FALSE;

}

TxBuffer[0] = 0x02;

}

//写硬锟斤拷选锟斤拷(锟斤拷锟斤拷锟斤拷锟揭拷薷锟接诧拷锟窖★拷锟�,锟剿诧拷锟斤拷锟街憋拷锟斤拷锟斤拷锟�)

DelayXms(10);

for (cnt=0; cnt<128; cnt++)

{

TxBuffer[cnt] = 0xff;

}

TxBuffer[0] = 0x04;

TxBuffer[1] = 0x00;

TxBuffer[2] = 0x00;

TxBuffer[34] = 0xfd;

TxBuffer[62] = arg;

TxBuffer[63] = 0x7f;

TxBuffer[64] = 0xf7;

TxBuffer[65] = 0x7b;

TxBuffer[66] = 0x1f;

CommSend(67);

while (1)

{

if (TimeOut == 0) return FALSE;

if (UartReceived)

{

if ((RxBuffer[0] == 0x04) && (RxBuffer[1] == 'T')) break;

return FALSE;

}

//锟斤拷锟斤拷锟斤拷锟�

return TRUE;

}

char code DEMO[256] =

{

0x02,0x00,0x5E,0x12,0x00,0x4B,0x75,0xB0,

0xEF,0x12,0x00,0x2C,0x75,0xB0,0xDF,0x12,

0x00,0x2C,0x75,0xB0,0xFE,0x12,0x00,0x2C,

0x75,0xB0,0xFD,0x12,0x00,0x2C,0x75,0xB0,

0xFB,0x12,0x00,0x2C,0x75,0xB0,0xF7,0x12,

0x00,0x2C,0x80,0xDA,0xE4,0xFF,0xFE,0xE4,

0xFD,0xFC,0x0D,0xBD,0x00,0x01,0x0C,0xBC,

0x01,0xF8,0xBD,0xF4,0xF5,0x0F,0xBF,0x00,

0x01,0x0E,0xBE,0x03,0xEA,0xBF,0xE8,0xE7,

0x02,0x00,0x4B,0x75,0x80,0xFF,0x75,0x90,

0xFF,0x75,0xA0,0xFF,0x75,0xB0,0xFF,0x75,

0xC0,0xFF,0x75,0xC8,0xFF,0x22,0x78,0x7F,

0xE4,0xF6,0xD8,0xFD,0x75,0x81,0x07,0x02,

0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

};

使锟斤拷锟斤拷锟斤拷MCU锟斤拷STC15系锟叫碉拷片锟斤拷锟斤拷锟叫达拷锟斤拷ISP锟斤拷锟截撅拷锟斤拷(锟斤拷锟节匡拷锟斤拷锟斤拷STC锟斤拷isp锟斤拷锟斤拷协锟介）

锟斤拷锟斤拷锟斤拷锟�

锟侥讹拷锟斤拷锟斤拷

锟狡硷拷锟斤拷锟斤拷