ch11_at89cxx 刻录程序彻底公开.c

8051单片机刻录程序彻底公开 用于单片机刻录器

/* AT89CXX programmer for FLAG51 */
/* program name:AT2051.C        */
/* writtern by Lin Shen Mou        */
/* 1996/02/28 add AT89C2051,1051   */
/* 1997/08/15 add AT89S8252        */
/* 1999/06/18 add AT89C4051        */

#include "c8051io.h"
#include "c8051sr.h"


#define AT_PIN     40
#define rate       0xfd
#define t_of_delay 8
#define AUTOLOCK   1
#define AT2051     0
#define AT4051     1
#define AT1051     2
#define AT89C51    3
#define AT89C52    4
#define AT89S8252  5
#define AT90S1200  6

#define AVR_ERASE       0x80
#define AVR_PGM_FLASH   0x10
#define AVR_PGM_EEPROM  0x11
#define AVR_FLASH_READ  0x02
#define AVR_EEPROM_READ 0x03
#define AVR_FUSE        0x40
#define AVR_LOCK_BIT    0x20
#define AVR_STATUS_READ 0x04
#define AVR_SIGNATURE_READ 0x08

#define IN_BUF   0xa000 /* a000-bfff */
#define OUT_BUF  0xc000 /* c000-dfff */
#define BUFFER   0xa000 /* a000-bfff 8192 bytes */

#define PPIPA1   0x6000
#define PPIPB1   0x6001
#define PPIPC1   0x6002
#define PPICTL1  0x6003

#define PPIPA2   0x7000
#define PPIPB2   0x7001
#define PPIPC2   0x7002
#define PPICTL2  0x7003

#define COUNT   65536-10000 /* 10 mS */
#define TmsH    (COUNT)/256
#define TmsL    (COUNT)%256
#define CMD_LINE 23

extern struct   special_function_bits   SFB;

const char hex_table[20] = { "0123456789ABCDEF" };
const char command[25][80]={
{  "*********** AT89 Series of FLASH Microcontroller programmer ************"},
{  "? or /    - Commands list                                          "},
{  "B lank    - Blank check of AT89C5X/X051                            "},
{  "E rase    - Erase internal flash memory                            "},
{  "P rogram  - Programming from RAM BUFFER                            "},
{  "A uto     - Erase,Blank check,Programming then Lock bit1 & bit2    "},
{  "V erify   - Verify AT89CXX & RAM BUFFER                            "},
{  "s ignature- Read signature of the chip                             "},
{  "L file    - Download binary file from PC to RAM BUFFER             "},
{  "S file    - Upload RAM BUFFER to PC                                "},
{  "1         - Lock bit1 of AT89CXX   (Futher programming is disabled)"},
{  "2         - Lock bit1+2 of AT89CXX (Verify is disabled)            "},
{  "3         - Lock bit1+2+3 of AT89C51/AT89C52/AT89S8252             "},
{  "R ead     - Read then save at RAM BUFFER                           "},
{  "D isplay  - Display RAM BUFFER (A000H-BFFFH)                       "},
{  "C hecksum - Calculate RAM BUFFER checksum                          "},
{  "X         - Clear memory RAM BUFFER                                "},
{  "F use     - Serial programmable Fuse ENABLE/DISABLE setting of AT89S8252"},
{  "*         - Start programming loop life_test                       "},
{  "O         - back to DOS shell                                      "},
{  "Q uit     - Exit                                                   "},
{  "<SHIFT>+1,2,3,4,5,6-Select AT89C1051/2051/4051/51/52/89S8252/AT90S1200"},
{  "***********************************************************************"}
  };
const char dummy1[100]  = { "XXXXX" };
const char title0[80]    =
     { "ATMEL's AT89 Microcontroller programmer V7.0" };
const char title1[80]    =
     { "program written by Lin S.M.  '99/06/18" };

const char title2[80] =
     { "Any questions about ATMEL FLASH Microcontroller,please call:" };
const char title3[80] =
     { "Technical HOT-LINE :886-7-3955152"    };
const char title4[80] =
     { "          or E-mail:[e-mail]"     };
const char title5[80] =
     { "Please read [README] file in disk before you program AT89CXX" };

const char dummy2[40]  = { "XXXXX" };
const char msg_at90s1200[12]={ "AT90S1200" };
const char msg_at89s8252[12]={ "AT89S8252" };
const char msg_at89c51[10]  ={ "AT89C51" };
const char msg_at89c52[10]  ={ "AT89C52" };
const char msg_at89c4051[12]={ "AT89C4051" };
const char msg_at89c2051[12]={ "AT89C2051" };
const char msg_at89c1051[12]={ "AT89C1051" };

const char msg_erase[40]    ={ "Erase flash memory" };
const char msg_blank[40]    ={ "Blank check..." };
const char msg_no_blank[40] ={ "Blank check fail !!" };
const char msg_verify[40]   ={ "Verify..." };
const char msg_verify_ok[40]={ "Verify OK on code data" };
const char msg_no_match[40] ={ "Verify fail !!"      };
const char msg_pgm[40]      ={ "Programming ..." };
const char msg_pass[40]     ={ "FLASH MEMORY programmed successfully" };
const char msg_fail[40]     ={ "Fail in programming" };

int display_char(char);
int display_char_no_wait(char);
int display_addr(unsigned int);
int display_str(char *s,int lf);
int display(char *s);
int test_count=0;
int flash_type;
int pgm_length,eeprom_length;
int checksum=0;
int vpp=12;

int main()
{
 int result;
 int s_in;
 int q;
 int prompt;

        init_8255(0x92,0x82);
        flash_type=read_CODE(0x7fff) & 0x07;
        if (flash_type<0 || flash_type>3) flash_type=AT89C51;
        select_pgm_length();

        for (q=1;q<=0x80;q*=2)
        { P1=q; delay(10); }
        P1=0;

        enable_int0();
        power_on_message();

        line_feed();
        display_str(title0,1);
        display_str(title1,1);
        line_feed();
        delay(200);
        display_str(title2,1);
        display_str(title3,1);
        display_str(title4,1);
        display_str(title5,1);
        line_feed();

        display_str("System ROM(0000H-7FFFH) checksum ",0);
        clear_buffer(8192);
/*      check_rom();    */

        display_str("OK!",1);
        display_str("System RAM(8000H-FFFFH) R/W function test -",1);
        check_mem();

        display_prompt();
 beep_start();

        while (1) {
         if (flash_type==AT2051 || flash_type==AT4051|| flash_type==AT1051 )
         {
          check_read_and_verify_sw();
          check_pgm_sw();
         }

        if (SFB.RI==1) {
        s_in=SBUF; /* read a command */
        SFB.RI=0;  /* reset RI flag */
        prompt=1;
        switch(s_in) {
         case '*':
                  line_feed();
                  life_test();
                  break;
         case 'F':
         case 'f':
                  line_feed();
                  if (flash_type==AT89S8252) {
                   beep_start();
                   result=read_at89s8252_SPF();
                   if (result==0) select_SPF(1); /* enable-> disable */
                   else           select_SPF(0); /* disable->enable  */
                   }
                  else beep_err();
                  break;
         case 'L':
         case 'l':
                  download_file();
                  beep_ok();
                  break;
         case 's':
                  line_feed();
                  show_signature(0);
                  beep_ok();
                  break;
         case 'r':
         case 'R':
                  line_feed();
                 display_str("Read then save into RAM BUFFER",1);
                  if (flash_type!=AT90S1200) checksum=chip_read();
                  else                       checksum=avr_flash_reading();
                  display_str("Checksum = ",0);
                  display_addr((unsigned int)checksum);
                  line_feed();
                  beep_ok();
                  break;
         case 'E':
         case 'e':
                  line_feed();
                  display_str(msg_erase,1);
                  if (flash_type !=AT90S1200) result=chip_erase();
                  else
                   { avr_erase();
                     result=avr_flash_blank();
                   }
                  if (result==0) display_str("Erase completed",1);
                  else           display_str("Erase fail!",1);
                  if (result==0) beep_ok();
                  else           beep_err();
                  break;
         case 'P':
         case 'p':if (flash_type !=AT90S1200) {
                   line_feed();
                   beep_start();
                   display_str(msg_erase,1);
                   result=chip_erase();
                   if (result==0) result=programming();
                  }
                  else
                  {
                   line_feed();
                   display_str("Programming AT90S1200...",1);
                   avr_flash_programming();
                   result=avr_flash_verify();
                  }

                  if (result==0) display_str(msg_pass,1);
                  else           display_str(msg_fail,1);
                  if (result==0) beep_ok();
                  else           beep_err();
                  if (result!=0)
                   {
                    show_fail_in_programming();
                    show_mail_box();
                   }
                  break;
         case 'S':
                  for (q=0;q<200;q++) delay_10ms();
                  upload_file();
                  break;
         case 'A':
         case 'a':
                  line_feed();
                  beep_start();
                  display_str(msg_erase,1);
                  chip_erase();
                  result=blank_check(32);
                  if (result==0) {
                   result=programming();
                  }
                  if (result==0) display_str(msg_pass,1);
                  else           display_str(msg_fail,1);

                  if (result==0) beep_ok();
                  else           beep_err();
                  if (result!=0)
                  {
                   show_fail_in_programming();
                   show_mail_box();
                  }
                 if (result==0) {
                  display_str("Lock bit1",1);
                  lock_bit1();
                  display_str("Lock bit2",1);
                  lock_bit2();
                  }
                  break;

         case 'V':
         case 'v':
                  line_feed();
                  if (flash_type !=AT90S1200)
                      result=verify(0); /* break if error happen */
                  else result=avr_flash_verify();

                  if (result==0) display_str(msg_verify_ok,1);
                  else           display_str(msg_no_match,1);
                  if (result==0) beep_ok();
                  else           beep_err();
                  break;
         case 'B':
         case 'b':
                  line_feed();
                  display_str("Blank checking...",1);
                  if (flash_type !=AT90S1200) result=blank_check(pgm_length);
                  else                        result=avr_flash_blank();
                  if (result==0) display_str("This chip is BLANK",1);
                  else           display_str("This chip is NOT BLANK!",1);
                  if (result==0) beep_ok();
                  else           beep_err();
                  show_signature(1);
                  break;
         case 'D':
         case 'd':
                   line_feed();
                   display_str("Display RAM BUFFER",1);
                   checksum=display_mem_block(BUFFER,BUFFER+pgm_length-1);
                   delay(50);
                   display_str("RAM BUFFER checksum = ",0);
                   display_addr((unsigned int)checksum);
                   line_feed();
                   break;
         case 'C':
         case 'c':
                  line_feed();
                  display_str("Calculate checksum = ",0);
                  checksum=calculate_checksum();
                  display_addr_woh((unsigned int)checksum);
                  line_feed();
                  break;
         case 'X':
         case 'x':
                  line_feed();
                  display_str("Clear RAM BUFFER to 00H",1);
                  clear_buffer(pgm_length);
                  beep_ok();
                  break;
         case '?':
         case '/':
                  line_feed();
                  command_list();
                  break;
         case '1':
                  line_feed();
                  display_str("Lock bit1",1);
                  lock_bit1();
                  beep_ok();
                  break;
         case '2':
                  line_feed();
                  display_str("bit2",1);
                  lock_bit2();
                  beep_ok();
                  break;
         case '3':
                  line_feed();
                  display_str("Lock bit3",1);
                  beep_ok();
                  break;
/*
         case 't':
         case 'T':
                  line_feed();
                  switch (flash_type)
                   {
                    case AT1051: flash_type=AT2051;
                                 display_str("Change type to AT89C2051 (2K)",1);
                                 break;
                    case AT2051: flash_type=AT4051;
                                 display_str("Change type to AT89C4051 (4K)",1);
                                 break;
                    case AT4051: flash_type=AT89C51;
                                 display_str("Change type to AT89C51 (4K)",1);
                                 break;
                    case AT89C51:flash_type=AT89C52;
                                 display_str("Change type to AT89C52 (8K)",1);
                                break;
                    case AT89C52:flash_type=AT89S8252;
                                 display_str("Change type to AT89S8252 (8K)",1);
                                 break;
                    case AT89S8252:flash_type=AT1051;
                                 display_str("Change type to AT89C1051 (2K)",1);
                                 break;
                    default:     break;
                   }
                  program_setting();
                  break;
*/
         case '!': line_feed();
                   flash_type=AT1051;
                   display_str("Change type to AT89C1051 (1K)",1);
                   program_setting();
                   break;
         case '@': line_feed();
                   flash_type=AT2051;
                   display_str("Change type to AT89C2051 (2K)",1);
                   program_setting();
                   break;
         case '#': line_feed(); flash_type=AT4051;
                   display_str("Change type to AT89C4051 (4K)",1);
                   program_setting();
                   break;
         case '$': line_feed(); flash_type=AT89C51;
                   display_str("Change type to AT89C51 (4K)",1);
                   program_setting();
                   break;
         case '%': line_feed(); flash_type=AT89C52;
                   display_str("Change type to AT89C52 (8K)",1);
                   program_setting();
                   break;
         case '^': line_feed(); flash_type=AT89S8252;
                   display_str("Change type to AT89S8252 (8K)",1);
                   program_setting();
                   break;
         case '&': line_feed();
                   flash_type=AT90S1200;
                   display("Change type to AT90S1200 (1K) ");
                   program_setting();
                   avr_8255_mode();
                   avr_read_mode();
                   break;
         case 0x0d:
         case 0x0a:
         case 0x00:
                  line_feed();
                  break;
         default:
                  line_feed();
                  display("Type '?' or '/' for help !");
                  beep_err();
                  break;
         }; /* end of switch */
         if (prompt==1) display_prompt();
        }
       } /* end of while (1) */
       return(0);
}    /* end of main program */


/* AT90S1200 programming code */
int avr_8255_mode()
{
        init_8255(0x80,0x82);   /* PPI1 all output,PPI2(PA,PC out),PB in */
        p20_rst_low();
        avr_bs_low();
        p20_rst_hi();
}

int avr_read_byte()
{
 int d;
        d=read_XDATA(PPIPB2);
        return(d);
}

int avr_read_mode()
{
        p20_write_byte(0xff); /* let PB out=FFH */
        avr_oe_hi();
        avr_wr_hi();
       avr_bs_low();
        p20_xtal1_low();
}

int avr_write_mode()
{
        avr_oe_hi();
        avr_wr_hi();
        avr_bs_low();
        p20_xtal1_low();
}

int avr_signature_reading()
{
 int d1,d2,d3;

/*      avr_8255_mode();        */
        p20_rst_12v();
        avr_command(AVR_SIGNATURE_READ);
        avr_load_lowaddr(0);
        avr_read_mode();
         avr_oe_low();
         d1=avr_read_byte();          /* read low byte */
         avr_oe_hi();

        avr_load_lowaddr(1);
        avr_read_mode();
         avr_oe_low();
         d2=avr_read_byte();          /* read low byte */
         avr_oe_hi();

        avr_load_lowaddr(2);
        avr_read_mode();
         avr_oe_low();
         d3=avr_read_byte();          /* read low byte */
         avr_oe_hi();

        p20_rst_hi();
        avr_idle();

        display_str("The AT90S1200 chip signatures are :",0);
        display_str(" (000H)=",0);  display_hex(d1);
        display_str("H,(001H)=",0); display_hex(d2);
        display_str("H,(002H)=",0); display_hex(d3);
        display_str("H",1);
}

int avr_flash_blank()
{
 int m,n,data;
 int err;

/*      avr_8255_mode();        */
        p20_rst_12v();
        avr_command(AVR_FLASH_READ);

        for (m=0,n=0,err=0;n<pgm_length;m+=1,n+=2)
        {
         avr_load_addr(m);
        p20_write_byte(0xff);
         avr_oe_low();  avr_bs_low();
         data=avr_read_byte();          /* read low byte */
         if (data!=0xff) { err=1; break; }

/*       avr_read_mode();       */
        p20_write_byte(0xff);
         avr_bs_hi();
         data=avr_read_byte();          /* read high byte */
         avr_oe_hi();
         if (data!=0xff) { err=1; break; }
         if ((m & 0x007f)==0) display_char('B');
        }
        line_feed();

        p20_write_byte(0xff);
        p20_rst_hi();
        return(err);
}

int avr_flash_verify()
{
 int m,n,data;
 int v,err;

       avr_8255_mode();
        p20_rst_12v();
        avr_command(AVR_FLASH_READ);

        for (m=0,n=0,err=0;n<pgm_length;m+=1,n+=2)
        {
         avr_load_addrall(m);
        p20_write_byte(0xff);
         avr_oe_low();  avr_bs_low();
         data=avr_read_byte();          /* read low byte */
         v=read_XDATA(BUFFER+n);