标题: 仿STC-ISP写的Linux版编程烧录软件，附源代码 [打印本页]

---

作者: mp3    时间: 2019-3-24 10:45
标题: 仿STC-ISP写的Linux版编程烧录软件，附源代码


只在STC11F04E单片机上试用过，其它型号可能要修改通信协议，可通过串口监控工具分析。

单片机脱机烧录源程序如下:

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. #include <stdlib.h>
   
4. #include <sys/types.h>
   
5. #include <sys/stat.h>
   
6. #include <fcntl.h>
   
7. #include <termios.h>
   
8. #include <sys/ioctl.h>
   
9. #include <string.h>
   
10. #include <arpa/inet.h>
    
11. #include <sys/time.h>
    
12. #include <ctype.h>
    
13. 
    
14. #pragma pack(1)
    
15. 
    
16. // config MCU clock
    
17. #define MCU_CONFIG
    
18. //#define MCU_6TO6
    
19. //#define MCU_6TO12
    
20. //#define MCU_12TO12
    
21. //#define MCU_12TO6
    
22. #ifdef MCU_6TO6
    
23. #define MCU_CLOCK
    
24. #endif
    
25. #ifdef MCU_6TO12
    
26. #define MCU_CLOCK
    
27. #endif
    
28. #ifdef MCU_12TO12
    
29. #define MCU_CLOCK
    
30. #define MCU_CLOCK_12MHZ
    
31. #undef MCU_CONFIG
    
32. #endif
    
33. #ifdef MCU_12TO6
    
34. #define MCU_CLOCK
    
35. #define MCU_CLOCK_12MHZ
    
36. #endif
    
37. #ifndef MCU_CLOCK
    
38. #error "You must define MCU clock!"
    
39. #endif
    
40. 
    
41. #define VERSION "0.1"
    
42. #define DEFAULT_PORT "/dev/ttyS1"
    
43. #define LOW_BAUD B2400
    
44. #ifdef MCU_CLOCK_12MHZ
    
45. #define HIGH_BAUD B57600
    
46. #define MSG_HIGH_BAUD "57600bps"
    
47. #else
    
48. #define HIGH_BAUD B38400
    
49. #define MSG_HIGH_BAUD "38400bps"
    
50. #endif
    
51. #define BUFFSIZE 1024
    
52. #define TIMEOUT 2
    
53. #define BLOCK_SIZE 128
    
54. 
    
55. #define PKG_MINIMAL_LEN 9
    
56. #define PKG_SIGN1 '\x46'
    
57. #define PKG_SIGN2 '\xb9'
    
58. #define PKG_SIGN3 '\x16'
    
59. #define PKG_SIGN  0x46b9
    
60. 
    
61. enum pkg_type {
    
62.         PKG_TYPE1=0x68,
    
63.         PKG_TYPE2=0x6a,
    
64. };
    
65. 
    
66. enum pkg_code {
    
67.         CODE_INFO=0x50,
    
68.         CODE_MODI=0x8f,
    
69.         CODE_NEWB=0x8e,
    
70.         CODE_ERASE=0x84,
    
71.         CODE_DATA=0x00,
    
72.         CODE_END =0x69,
    
73.         CODE_CONF=0x8d,
    
74.         CODE_BYE =0x82,
    
75. };
    
76. 
    
77. int port_fd=-1;
    
78. FILE *rom_file;
    
79. int file_length;
    
80. int debug=0;
    
81. enum pkg_code step;
    
82. int block_no;
    
83. struct timeval start_tv;
    
84. 
    
85. typedef unsigned int uint32;
    
86. typedef unsigned short int uint16;
    
87. typedef unsigned char uint8;
    
88. 
    
89. // Package format: head + data + tail
    
90. typedef struct _pkg_head {
    
91.         uint16 sign;                // 0x46b9
    
92.         uint8  type;                // 68: MCU to PC; 6a: PC to MCU
    
93.         uint16 lenth;                // from 'type' to 'pkg_tail.sign'
    
94.         uint8  code;
    
95. } pkg_head, *ppkg_head;
    
96. 
    
97. typedef struct _pkg_tail {
    
98.         uint16 cksum;                // from 'pkg_head.type' to 'data'
    
99.         uint8  sign;                // 0x16
    
100. } pkg_tail, *ppkg_tail;
     
101. 
     
102. typedef struct _pkg_data_head {
     
103.         uint16 dummy;                // always 0x0000
     
104.         uint16 addr;                // start addr
     
105.         uint16 lenth;                // 0x0080
     
106. } pkg_data_head, *ppkg_data_head;
     
107. 
     
108. void print_data(char *data, int len)
     
109. {
     
110.         unsigned char ch;
     
111.         int i, j;
     
112.         printf("Length: %x\n", len);
     
113.         for(i=0; i<len; i++) {
     
114.                 ch=data[i];
     
115.                 if((i&0x0f)==0)
     
116.                         printf("%04x: ", i);
     
117.                 if((i&0x07)!=0x07)
     
118.                         printf("%02x ", ch);
     
119.                 else
     
120.                         if((i&0x0f)!=0x0f)
     
121.                                 printf("%02x-", ch);
     
122.                         else {
     
123.                                 printf("%02x  ", ch);
     
124.                                 for(j=0x0f; j>=0; j--) {
     
125.                                         ch=data[i-j];
     
126.                                         if(!isascii(ch) || iscntrl(ch))
     
127.                                                 ch='.';
     
128.                                         putchar(ch);
     
129.                                 }
     
130.                                 putchar('\n');
     
131.                         }
     
132.         }
     
133.         if(len&0x0f) {
     
134.                 for(; i<(len&~0x0f)+0x10; i++)
     
135.                         printf("   ");
     
136.                 putchar(' ');
     
137.                 for(j=len&~0x0f; j<len; j++) {
     
138.                         ch=data[j];
     
139.                         if(!isascii(ch) || iscntrl(ch))
     
140.                                 ch='.';
     
141.                         putchar(ch);
     
142.                 }
     
143.                 putchar('\n');
     
144.         }
     
145. }
     
146. 
     
147. enum dbg_type {RECV, SEND};
     
148. void print_dbg(int type, char *buf, int buf_len)
     
149. {
     
150.         struct timeval tv;
     
151.         unsigned int sec, usec;
     
152.         if(debug) {
     
153.                 if(type==SEND)
     
154.                         printf("\n[Send]\t\t");
     
155.                 else
     
156.                         printf("\n[Received]\t");
     
157.                 gettimeofday(&tv, NULL);
     
158.                 if(start_tv.tv_usec>tv.tv_usec) {
     
159.                         usec=tv.tv_usec-start_tv.tv_usec+1000000;
     
160.                         sec=tv.tv_sec-start_tv.tv_sec-1;
     
161.                 } else {
     
162.                         usec=tv.tv_usec-start_tv.tv_usec;
     
163.                         sec=tv.tv_sec-start_tv.tv_sec;
     
164.                 }
     
165.                 printf("[%d.%06d]\n", sec, usec);
     
166.                 printf("Step: %02x\t", step);
     
167.                 print_data(buf, buf_len);
     
168.         }
     
169. }
     
170. 
     
171. int checksum(char *buf, int buf_len)
     
172. {
     
173.         int i, sum=0;
     
174.         for(i=0; i<buf_len; i++)
     
175.                 sum+=(unsigned char)buf[i];
     
176.         return sum;
     
177. }
     
178. 
     
179. // return: -1: bad pkg; >=0: pkg start position
     
180. int check_pkg(int code, char *buf, int buf_len)
     
181. {
     
182.         int i, len;
     
183.         ppkg_head ph=NULL;
     
184.         ppkg_tail pt=NULL;
     
185.         for(i=0; i<buf_len; i++) {
     
186.                 if(buf[i]==PKG_SIGN1 && buf[i+1]==PKG_SIGN2 && i+PKG_MINIMAL_LEN<=buf_len) {
     
187.                         ph=(ppkg_head)buf+i;
     
188.                         if(ph->type==PKG_TYPE1 && ph->code==code) {
     
189.                                 len=ntohs(ph->lenth);
     
190.                                 pt=(ppkg_tail)((char *)ph+len-1);
     
191.                                 if(pt->sign==PKG_SIGN3 && ntohs(pt->cksum)==checksum((char *)ph+2, len-3)) break;
     
192.                                 pt=NULL;
     
193.                                 break;
     
194.                         }
     
195.                 }
     
196.         }
     
197.         if(ph==NULL || pt==NULL)
     
198.                 i=-1;
     
199.         return i;
     
200. }
     
201. 
     
202. typedef struct port_info {
     
203.         int port_fd;
     
204.         int baud_rate;
     
205.         char parity;
     
206.         char stop_bit;
     
207.         char flow_ctrl;
     
208.         char data_bits;
     
209. } *pport_info;
     
210. 
     
211. int set_port(pport_info p_info)
     
212. {
     
213.         struct termios old_opt,new_opt;
     
214.         memset(&old_opt,0,sizeof(old_opt));
     
215.         memset(&new_opt,0,sizeof(new_opt));
     
216. 
     
217.         cfmakeraw(&new_opt);
     
218.         tcgetattr(p_info->port_fd,&old_opt);
     
219.         
     
220.         //修改new_opt结构中的串口输入/输出波特率参数
     
221.         cfsetispeed(&new_opt,p_info->baud_rate);
     
222.         cfsetospeed(&new_opt,p_info->baud_rate);
     
223.         
     
224.         //修改控制模式，保证程序不会占用串口
     
225.         new_opt.c_cflag |=CLOCAL;
     
226.         //修改控制模式，使得能够从串口中读取输入数据
     
227.          new_opt.c_cflag |=CREAD;
     
228. 
     
229.         /*===========设置数据流控制==========*/
     
230.         switch(p_info->flow_ctrl){
     
231.                 case '0':
     
232.                         //不使用流控制
     
233.                         new_opt.c_cflag &=~CRTSCTS;
     
234.                         break;
     
235.                 case '1':
     
236.                         //使用硬件进行流控制
     
237.                         new_opt.c_cflag |=CRTSCTS;
     
238.                         break;
     
239.                 case '2':
     
240.                         new_opt.c_cflag |= IXON | IXOFF | IXANY;
     
241.                         break;
     
242.         }
     
243.         
     
244.         /*===========设置数据位============*/
     
245.         new_opt.c_cflag &=~CSIZE;
     
246.         switch(p_info->data_bits){
     
247.                 case '5':
     
248.                         new_opt.c_cflag |=CS5;
     
249.                         break;
     
250.                 case '6':
     
251.                         new_opt.c_cflag |=CS6;
     
252.                         break;
     
253.                 case '7':
     
254.                         new_opt.c_cflag |=CS7;
     
255.                         break;
     
256.                 case '8':
     
257.                         new_opt.c_cflag |=CS8;
     
258.                         break;
     
259.                 default:
     
260.                         new_opt.c_cflag |=CS8;
     
261.                 }
     
262. 
     
263.         /*===========设置奇偶效验位==========*/
     
264.         switch(p_info->parity){
     
265.                 case '0':        //不使用奇偶效验
     
266.                         new_opt.c_cflag &=~PARENB;
     
267.                         break;
     
268.                 case '1':        //使用偶效验
     
269.                         new_opt.c_cflag |=PARENB;
     
270.                         new_opt.c_cflag &=~PARODD;
     
271.                         break;
     
272.                 case '2':        //使用奇效验
     
273.                         new_opt.c_cflag |=PARENB;
     
274.                         new_opt.c_cflag |=PARODD;
     
275.                         break;
     
276.         }
     
277. 
     
278.         /*============设置停止位===========*/
     
279.         if(p_info->stop_bit=='2')
     
280.                 new_opt.c_cflag |=CSTOPB;
     
281.         else
     
282.                 new_opt.c_cflag &=~CSTOPB;
     
283. 
     
284.         //修改输出模式，原始数据输出
     
285.         new_opt.c_oflag &=~OPOST;
     
286.         //修改控制字符，读取字符的最少个数为1
     
287.         new_opt.c_cc[VMIN]=1;
     
288.         //修改控制字符，读取第一个字符等待1*（1/10）s
     
289.         new_opt.c_cc[VTIME]=1;
     
290. 
     
291.         //如果发生数据溢出，接收数据，但是不再读取
     
292.         tcflush(p_info->port_fd,TCIFLUSH);
     
293.         
     
294.         int result=tcsetattr(p_info->port_fd,TCSANOW,&new_opt);
     
295.         if(result==-1){
     
296.                 perror("Cannot set the serial port parameters");
     
297.                 return -1;
     
298.         }
     
299. 
     
300.         tcgetattr(p_info->port_fd,&old_opt);
     
301.         return result;
     
302. }
     
303. 
     
304. int open_port(char *port_name, int baud_rate)
     
305. {
     
306.         int port_fd;
     
307. 
     
308.         if((port_fd=open(port_name, O_RDWR | O_NOCTTY | O_NONBLOCK))==-1){
     
309.                 fprintf(stderr, "Failed to open serial port: %s\n", port_name);
     
310.                 return -1;
     
311.         }
     
312. 
     
313.         //设置串口通信参数
     
314.         struct port_info info;
     
315.         info.port_fd=port_fd;
     
316.         info.baud_rate=baud_rate;
     
317.         info.data_bits='8';
     
318.          info.flow_ctrl='0';
     
319.         info.stop_bit='1';
     
320.         info.parity='1';
     
321.         if(set_port(&info)==-1) {
     
322.                 fprintf(stderr, "Failed to setup serial port: %s\n", port_name);
     
323.                 close(port_fd);
     
324.                 return -1;
     
325.         }
     
326.         return port_fd;
     
327. }
     
328. 
     
329. void close_port()
     
330. {
     
331.         if(rom_file!=NULL) {
     
332.                 fclose(rom_file);
     
333.                 rom_file=NULL;
     
334.         }
     
335.         if(port_fd!=-1) {
     
336.                 close(port_fd);
     
337.                 port_fd=-1;
     
338.         }
     
339. }
     
340. 
     
341. void reopen_port(char *port_name, int baud_rate)
     
342. {
     
343.         if(port_fd!=-1)
     
344.                 close(port_fd);
     
345.         if((port_fd=open_port(port_name, baud_rate))==-1)
     
346.         {
     
347.                 close_port();
     
348.                 exit(1);
     
349.         }
     
350. }
     
351. 
     
352. int send_data(int fd, char *data, int data_len)
     
353. {
     
354.         int len=write(fd, data, data_len);
     
355.         //如果出现溢出的情况
     
356.         if(len!=data_len)
     
357.                 tcflush(fd, TCOFLUSH);
     
358.         return len;
     
359. }
     
360. 
     
361. int send_mcu(int fd, char *data, int data_len)
     
362. {
     
363.         int i, len=0, total=0;
     
364.         for(i=0; i<data_len; i++) {
     
365.                 usleep(150);
     
366.                 len=send_data(fd,data+i,1);
     
367.                 if(len>0)
     
368.                         total+=len;
     
369.         }
     
370.         print_dbg(SEND, data, total);
     
371.         return total;
     
372. }
     
373. 
     
374. int recv_data(int fd, char *data, int data_len)
     
375. {
     
376.         static int timeout=0;
     
377.         int len=0, fs_sel;
     
378.         fd_set fs_read;
     
379.         struct timeval time;
     
380. 
     
381.         FD_ZERO(&fs_read);
     
382.         FD_SET(fd, &fs_read);
     
383.         if(step==CODE_MODI)
     
384.                 timeout=TIMEOUT;
     
385.         time.tv_sec=timeout;
     
386.         time.tv_usec=10000;
     
387. 
     
388.         //使用select实现串口的多路通信
     
389.         fs_sel=select(fd+1, &fs_read, NULL, NULL, &time);
     
390.         if(fs_sel)
     
391.                 len=read(fd, data, data_len);
     
392.         return len;
     
393. }
     
394. 
     
395. int recv_mcu(int fd, char *buf, int buf_len)
     
396. {
     
397.         int i, len=0;
     
398.         do {
     
399.                 if(step==CODE_INFO)
     
400.                         usleep(100000);
     
401.                 i=recv_data(fd, buf+len, buf_len-len);
     
402.                 if(i>0) len+=i;
     
403.                 if(check_pkg(step, buf, len)>=0)
     
404.                         break;
     
405.         } while(i>0);
     
406.         return len;
     
407. }
     
408. 
     
409. int check_recv(int expect_code, char *buf, int buf_len) {
     
410.         int i;
     
411.         print_dbg(RECV, buf, buf_len);
     
412.         i=check_pkg(expect_code, buf, buf_len);
     
413.         if(i<0) {
     
414.                 printf("\nError received data\n");
     
415.                 close_port();
     
416.                 exit(1);
     
417.         }
     
418.         return i;
     
419. }
     
420. 
     
421. void mcu_info(char *buf, int buf_len) {
     
422.         int i, len;
     
423.         ppkg_head ph;
     
424.         ppkg_tail pt;
     
425.         ph=(ppkg_head)buf;
     
426.         len=ntohs(ph->lenth);
     
427.         pt=(ppkg_tail)((char *)ph+len-1);
     
428. 
     
429. /*
     
430. MCU Type is: STC11F04E
     
431. MCU Firmware Version: 6.5K
     
432. Next Power-Up-Reset, use External Crystal/Clock
     
433. RESET/P3.6 is used as RESET
     
434. Power-Up Reset,add extra Reset-Delay-Time
     
435. Oscillator Gain:                 High gain
     
436. P1.0/P1.1 are not related to STC ISP Programming
     
437. Next ISP Programming Code,don't erase EEPROM data
     
438. Wait n clocks after MCU is waked up: 32768
     
439. Low Voltage Reset, when MCU-VCC < 4.1V
     
440. WDT_CONTR be write-protected except CLR_WDT:NO
     
441. WDT is enabled automatically during power-up:NO
     
442. Stop WatchDog Timer counting in Idle mode:  YES
     
443. Pre-scale time of WDT(did not start): 256
     
444. MCU Clock:12.019038MHz.
     
445. */
     
446.         i=sizeof(pkg_head)+16;
     
447.         printf("\n\nMCU Type: \n");
     
448.         printf("MCU Firmware Version: %1d.%1d%c\n", buf[i]>>4&0x0f, buf[i]&0x0f, buf[i+1]);
     
449.         i=ntohl(*((int *)((char *)pt-4)));
     
450.         printf("MCU Internal Clock: %2d.%6dMhz\n", i/1000000, i%1000000);
     
451. }
     
452. 
     
453. //return: pkg length
     
454. int make_pkg(int code, char *inbuf, int ibuf_len, char *outbuf, int obuf_len)
     
455. {
     
456.         int i, len;
     
457.         ppkg_head ph;
     
458.         ppkg_tail pt;
     
459.         ppkg_data_head pd;
     
460. 
     
461.         static char request_mcu[]={
     
462. 0x46,0xB9,0x6A,0x00,0x0D,0x50,0x09,0x00,0x36,0x01,0xE2,0x24,0x02,0x0D,0x16};
     
463.         static char erase[]={
     
464. 0x46,0xB9,0x6A,0x00,0x8C,0x84,0xFF,0x00,0x02,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
     
465.         static char end[]={
     
466. 0x46,0xB9,0x6A,0x00,0x0D,0x69,0x09,0x00,0x36,0x01,0xE2,0x24,0x02,0x26,0x16};
     
467.         static char bye[]={
     
468. 0xFE,0xFE,0xFE,0xFE,0x46,0xB9,0x6A,0x00,0x07,0x82,0x00,0xF3,0x16};
     
469. 
     
470. /* 38400bps @ 6.2MHz, internal clock */
     
471. #ifdef MCU_6TO6
     
472.         static char inform_change[]={
     
473. 0x46,0xB9,0x6A,0x00,0x0D,0x8F,0xC0,0xF6,0x3F,0x14,0x2D,0x84,0x03,0xC0,0x16};
     
474.         static char confirm_newrate[]={
     
475. 0x46,0xB9,0x6A,0x00,0x0C,0x8E,0xC0,0xF6,0x3F,0x14,0x2D,0x03,0x3A,0x16};
     
476.         static char config[]={
     
477. 0x46,0xB9,0x6A,0x00,0x1B,0x8D,0xBF,0x7D,0xF7,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x5E,0x90,0x04,0x11,0x2A,0x16};
     
478. #endif
     
479. 
     
480. /* 38400bps @ 6.2MHz, change 6.2MHz to 12MHz */
     
481. #ifdef MCU_6TO12
     
482.         static char inform_change[]={
     
483. 0x46,0xB9,0x6A,0x00,0x0D,0x8F,0xC0,0xF6,0x3F,0x14,0x2D,0x84,0x03,0xC0,0x16};
     
484.         static char confirm_newrate[]={
     
485. 0x46,0xB9,0x6A,0x00,0x0C,0x8E,0xC0,0xF6,0x3F,0x14,0x2D,0x03,0x3A,0x16};
     
486.         static char config[]={
     
487. 0x46,0xB9,0x6A,0x00,0x1B,0x8D,0xBF,0x7F,0xF7,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x5E,0x27,0x41,0x11,0x00,0x16};
     
488. #endif
     
489. 
     
490. /* 57600bps @ 12MHz, change back to 6.2MHz if run conf_mcu() */
     
491. #ifdef MCU_CLOCK_12MHZ
     
492.         static char inform_change[]={
     
493. 0x46,0xB9,0x6A,0x00,0x0D,0x8F,0xC0,0xF3,0x3F,0x1A,0x2D,0x83,0x03,0xC2,0x16};
     
494.         static char confirm_newrate[]={
     
495. 0x46,0xB9,0x6A,0x00,0x0C,0x8E,0xC0,0xF3,0x3F,0x1A,0x2D,0x03,0x3D,0x16};
     
496.         static char config[]={
     
497. 0x46,0xB9,0x6A,0x00,0x1B,0x8D,0xBF,0x7D,0xF7,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0xB7,0x65,0x5E,0x11,0xB2,0x16};
     
498. #endif
     
499. 
     
500.         switch(code) {
     
501.         case CODE_INFO:
     
502.                 len=sizeof(request_mcu);
     
503.                 memcpy(outbuf, request_mcu, len);
     
504.                 break;
     
505.         case CODE_MODI:
     
506.                 len=sizeof(inform_change);
     
507.                 memcpy(outbuf, inform_change, len);
     
508.                 break;
     
509.         case CODE_NEWB:
     
510.                 len=sizeof(confirm_newrate);
     
511.                 memcpy(outbuf, confirm_newrate, len);
     
512.                 break;
     
513.         case CODE_ERASE:
     
514.                 len=sizeof(erase);
     
515.                 memcpy(outbuf, erase, len);
     
516.                 *(short int *)(outbuf+7)=htons((file_length+255)>>8);
     
517.                 for(i=0x80; i>=0x0e; i--)
     
518.                         outbuf[len++]=i;
     
519.                 i=htons(checksum(outbuf+2, len-2));
     
520.                 *(int *)(outbuf+len)=i;
     
521.                 len+=2;
     
522.                 outbuf[len++]=PKG_SIGN3;
     
523.                 break;
     
524.         case CODE_DATA:
     
525.                 ph=(ppkg_head)outbuf;
     
526.                 ph->sign=htons(PKG_SIGN);
     
527.                 ph->type=PKG_TYPE2;
     
528.                 i=sizeof(pkg_head)+sizeof(pkg_data_head);
     
529.                 len=i+ibuf_len+sizeof(pkg_tail);
     
530.                 ph->lenth=htons(len-2);
     
531.                 ph->code=CODE_DATA;
     
532.                 pd=(ppkg_data_head)(outbuf+sizeof(pkg_head));
     
533.                 pd->dummy=htons(0x0000);
     
534.                 pd->addr=htons(block_no*BLOCK_SIZE);
     
535.                 pd->lenth=htons(ibuf_len);
     
536.                 memcpy(outbuf+i, inbuf, ibuf_len);
     
537.                 pt=(ppkg_tail)(outbuf+i+ibuf_len);
     
538.                 pt->cksum=htons(checksum(outbuf+2, i+ibuf_len-2));
     
539.                 pt->sign=PKG_SIGN3;
     
540.                 break;
     
541.         case CODE_END:
     
542.                 len=sizeof(end);
     
543.                 memcpy(outbuf, end, len);
     
544.                 break;
     
545.         case CODE_CONF:
     
546.                 len=sizeof(config);
     
547.                 memcpy(outbuf, config, len);
     
548.                 break;
     
549.         case CODE_BYE:
     
550.                 len=sizeof(bye);
     
551.                 memcpy(outbuf, bye, len);
     
552.                 break;
     
553.         default:
     
554.                 fprintf(stderr, "make_pkg(): invalid package code\n");
     
555.                 len=0;
     
556.         }
     
557.         return len;
     
558. }
     
559. 
     
560. // return: 0: fail; 1: success
     
561. int conf_mcu(char *port_name, int baud_rate)
     
562. {
     
563.         int i, len=0;
     
564.         char recv_buf[BUFFSIZE], send_buf[BUFFSIZE];
     
565. 
     
566.         reopen_port(port_name, baud_rate);
     
567.         step=CODE_CONF;
     
568.         len=make_pkg(step, recv_buf, len, send_buf, BUFFSIZE);
     
569.         len=send_mcu(port_fd, send_buf, len);
     
570.         step=CODE_INFO;
     
571.         len=recv_mcu(port_fd, recv_buf, BUFFSIZE);
     
572.         i=check_recv(step, recv_buf, len);
     
573.         step=CODE_BYE;
     
574.         len=make_pkg(step, recv_buf+i, len-i, send_buf, BUFFSIZE);
     
575.         len=send_data(port_fd, send_buf, len);
     
576.         close_port();
     
577.         if(i>=0)
     
578.                 i=1;
     
579.         else
     
580.                 i=0;
     
581.         return i;
     
582. }
     
583. 
     
584. void help(char *cmd_name)
     
585. {
     
586.         printf("STC MCU flash ROM programmer, Version " VERSION " (2011), GPLv2 Lisence\n");
     
587.         printf("Warning: this is not an official release, use it on your own risk.\n\n");
     
588.         printf("Surpport MCU type: STC11F04E\n\n");
     
589.         printf("Usage:\n  %s [options] [.bin filename]\n\n", cmd_name);
     
590.         printf("Options:\n  -h\t\tprint this text\n"
     
591.         "  -d dev\tuse given device, default: " DEFAULT_PORT "\n"
     
592.         "  -D\t\tenable debug output\n");
     
593.         exit(0);
     
594. }
     
595. 
     
596. int main(int argc, char *argv[])
     
597. {
     
598.         static char default_dev[]=DEFAULT_PORT;
     
599.         char *port_name=default_dev;
     
600.         char *file_name=NULL;
     
601.         int i, len;
     
602.         char recv_buf[BUFFSIZE], send_buf[BUFFSIZE];
     
603. 
     
604.         while((i=getopt(argc, argv, "hd:D"))!=-1) {
     
605.                 switch(i) {
     
606.                 case 'h':
     
607.                         help(argv[0]);
     
608.                         break;
     
609.                 case 'd':
     
610.                         port_name=optarg;
     
611.                         break;
     
612.                 case 'D':
     
613.                         debug=1;
     
614.                         break;
     
615.                 case '?':
     
616.                         exit(1);
     
617.                 }
     
618.         }
     
619.         for(; optind<argc; optind++) {
     
620.                 file_name=argv[optind];
     
621.                 break;
     
622.         }
     
623.         if(file_name!=NULL) {
     
624.                 if(strcasestr(file_name, ".bin")==NULL) {
     
625.                         fprintf(stderr, "Invalid file name\n");
     
626.                         exit(1);
     
627.                 }
     
628.                 rom_file=fopen(file_name, "rb");
     
629.                 if(rom_file==NULL) {
     
630.                         fprintf(stderr, "Cannot open file\n");
     
631.                         exit(1);
     
632.                 }
     
633.                 i=fileno(rom_file);
     
634.                 if(fstat(i, (struct stat *)recv_buf)==-1) {
     
635.                         perror("Cannot get length of the file\n");
     
636.                         close_port();
     
637.                         exit(1);
     
638.                 }
     
639.                 file_length=((struct stat *)recv_buf)->st_size;
     
640.         }
     
641. 
     
642.         printf("Use port %s\n", port_name);
     
643.         printf("Connecting to target MCU at 2400bps ...   ");
     
644.         if((port_fd=open_port(port_name, LOW_BAUD))==-1)
     
645.                 exit(1);
     
646. 
     
647.         // Power off and power on MCU via DTR & RTS signal
     
648.     ioctl(port_fd, TIOCMGET, &i);
     
649.         i&=~(TIOCM_RTS | TIOCM_DTR);
     
650.         ioctl(port_fd, TIOCMSET, &i);
     
651.         usleep(100000);
     
652.         i|=TIOCM_RTS | TIOCM_DTR;
     
653.         ioctl(port_fd, TIOCMSET, &i);
     
654. 
     
655.         step=CODE_INFO;
     
656.         for(i=150; i>0; i--) {
     
657.                 len=send_data(port_fd, "\x7f\x7f\x7f\x7f", 4);
     
658.                 if(len<1) {
     
659.                         printf("\b\bSend data failed\n");
     
660.                         close_port();
     
661.                         exit(1);
     
662.                 }
     
663. 
     
664.                 if(i%5==0) {
     
665.                         printf("\b\b%2d", i/5);
     
666.                         fflush(stdout);
     
667.                 }
     
668. 
     
669.                 len=recv_mcu(port_fd, recv_buf, BUFFSIZE);
     
670.                 if(len>=PKG_MINIMAL_LEN)
     
671.                         break;
     
672.         }
     
673.         if(len<PKG_MINIMAL_LEN) {
     
674.                 printf("\b\bFailed\n");
     
675.                 close_port();
     
676.                 exit(1);
     
677.         }
     
678. 
     
679.         gettimeofday(&start_tv, NULL);
     
680.         i=check_recv(step, recv_buf, len);
     
681.         mcu_info(recv_buf+i, len-i);
     
682.         if(rom_file==NULL) {
     
683.                 close_port();
     
684.                 exit(0);
     
685.         }
     
686. 
     
687.         // confirm MCU, procedure: make_pkg -> send -> recv -> check_recv
     
688.         len=make_pkg(step, recv_buf+i, len-i, send_buf, BUFFSIZE);
     
689.         len=send_mcu(port_fd, send_buf, len);
     
690.         step=CODE_MODI;
     
691.         len=recv_mcu(port_fd, recv_buf, BUFFSIZE);
     
692.         i=check_recv(step, recv_buf, len);
     
693. 
     
694.         // Inform to modify baud rate
     
695.         if(debug) printf("\nInform MCU to modify baud rate ...\n");
     
696.         len=make_pkg(step, recv_buf+i, len-i, send_buf, BUFFSIZE);
     
697.         len=send_mcu(port_fd, send_buf, len);
     
698.         reopen_port(port_name, HIGH_BAUD);
     
699.         len=recv_mcu(port_fd, recv_buf, BUFFSIZE);
     
700.         i=check_recv(step, recv_buf, len);
     
701. 
     
702.         // Send at 2400bps to confirm the new baud rate
     
703.         if(debug) printf("\nConfirm MCU with new baud rate ... \n");
     
704.         step=CODE_NEWB;
     
705.         reopen_port(port_name, LOW_BAUD);
     
706.         len=make_pkg(step, recv_buf+i, len-i, send_buf, BUFFSIZE);
     
707.         len=send_mcu(port_fd, send_buf, len);
     
708. 
     
709.         // Change to new baud rate
     
710.         printf("\nReconnecting to target MCU at " MSG_HIGH_BAUD " ... ");
     
711.         step=CODE_ERASE;
     
712.         reopen_port(port_name, HIGH_BAUD);
     
713.         
     
714.         ********余下代码下载附件*********
     

复制代码

所有资料51hei提供下载:
stc-isp.rar (5.88 KB, 下载次数: 68)

2019-3-24 10:38 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: 51hei团团    时间: 2019-3-25 03:29
高手,能不能请教下如何编译,这些头文件怎么办?

---

作者: mp3    时间: 2019-3-25 08:46

51hei团团 发表于 2019-3-25 03:29
高手,能不能请教下如何编译,这些头文件怎么办?

忘了说明，这个是在Linux下用。

---

作者: 51hei团团    时间: 2019-3-25 16:53
牛逼的作品.好资料，51黑有你更精彩!!!

---

作者: hzjgyr    时间: 2019-8-21 02:26
如果你们看见，能写中文注释吗？看不懂呀

---

作者: 闲来无事    时间: 2019-12-11 20:46
好东西，不知道楼主能否联系一下，想要定做一款isp

---

作者: jk8363298    时间: 2020-2-11 23:40
大神，正想找这样的资料，膜拜下先

---

作者: 860451472    时间: 2020-3-13 10:28
正有需要，感谢大佬分享。

---

作者: Lprong    时间: 2020-3-13 17:45
哇，好棒的程序！

---

作者: a461624201    时间: 2020-7-21 19:40
sudo gcc stc-isp.c   -o stc-isp     会出现错误
解决：www点cnblogs点com/liwei0526vip/p/4873109.html

---

作者: a461624201    时间: 2020-7-21 22:12
转载：www点cnblogs点com/sky1991/archive/2012/08/08/2627575.html

用 objcopy 也可以把 hex文件转化为bin'文件，姑且我就先这么用了。

生成hex文件后，用如下命令将hex转化为bin

objcopy -I ihex -O binary liushui.hex liushui.bin # I 和O 都是大写

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1