干货 | DIY 一个 ARM 学习机

我对底层的东西特别感兴趣。十多年前有了自己的电脑，一直保留DOS用了好些年。喜欢汇编，讨厌Java。接触的第一个单片机是AT89S52，下程序是用串口CTS/RTS以及DSR/DTR控制线来模拟SPI，在DOS下把时钟中断调到几十kHz来定时确定时序。后来就用89S52做成了2051的编程器，再后来用2051做了串口转SPI下载器玩起AVR了，玩过最多的还是AVR.

不过51、AVR这类Harvard结构MCU不能干的事情是自己Load程序来运行，只能从ROM执行啊(51可以有办法映射，但是51学习机计划没有实施)。我小时候听说过“中华学习机”，不同于小霸王学习机那样ROM固化死了的，人家是从软盘装载程序的。家里头的旧杂志上介绍过TD-I型8031的学习机，是用开关来二进制编程RAM然后执行的，倘若放到今天……

我生活的时代已经不是穿孔纸带了，DIY还是玩现代的东西吧。言归正传，我的第一个“学习机”作品是ARM7TDMI的，尽管这个核已经早过时了。我选择了NXP的LPC2220作为处理器，它自带64kB的RAM，在单片机中算是大的了。核心比较简单，作为学习机适宜，而且有外部总线，比较方便扩展RAM，类似PC那样来玩。这个PCB做得比较早了，搁置没玩起来（手头没时间玩的板子多了，这是另外的问题），上面除了MCU还有一块16bit*256k的SRAM，一片8bit*128k的NOR Flash ROM，预留16-bit总线插针扩展，具备一个计算机的配置了（除了缺少DMA支持）。下面是线路图：

PCB的顶层图

 
　PCB的底层：

 

作为MCU自带的外设是可以引出来的，所以UART, SPI, I2C基本I/O通信用分组接到插针，再另外放了16个GPIO在一侧。核心部分先焊上就可以玩了。

 
上面介绍的是硬件部分。LPC2220是为数不多的ROMless单片机，里面没有Flash哦，OTP也没有。这也是我选择它的原因，作为学习机不是做任何应用的原型板，烧写Flash尽量避免吧。虽然Flash的烧写次数已经够多了，能省一事算一事。NXP的ARM7 (LPC21xx系列)有个特点是可以从PC直接ISP下载到RAM，然后运行。我在第一次玩ARM (LPC2103)的时候发现Flash工具有这个功能。

读NXP的手册，发现Bootloader是使用串口命令进行交互的，命令也不复杂。

所以，只要连接MCU的UART0到PC的串口，上电或者复位就进入Bootloader里面的ISP程序(因为没有可执行的ROM嘛)，就可以从PC把代码直接下载到ROM然后运行了。64kB的SRAM哦，可以实现不少东西了吧。

当然，用NXP官方的FlashMagic来下载的效率太低了，不适应“学习机"要快速载入程序的要求。所以我自己做一个程序：

1. #include<windows.h>
   

2. #include<stdio.h>
   

3. #include<string.h>
   

4. #include<stdlib.h>
   

6. HANDLE dev;
   

7. OVERLAPPED oWR = {0}, oRD={0};
   

9. void errexit(char *s)
   

10. {
    

11.   fprintf(stderr,"%s",s);
    

12.   exit(1);
    

13. }
    

15. struct ROM
    

16. {
    

17.   unsigned char b;
    

18.   char oc;
    

19. };
    

22. int readcomm(unsigned char *buf, int maxlen, int timeout);
    

23. int writecomm(unsigned char *buf, int len);
    

25. int loadhexfile(char *fn,int szlimit,int *poff,struct ROM *rom);
    

26. int showbinary(int szlimit, struct ROM *rom);
    

27. int uuencode(int szlimit, struct ROM *rom, char *buf, int slen, int linelen);
    

28. int checksum(int szlimit, struct ROM *rom);
    

30. main(int argc, char *argv[])
    

31. {
    

33.    DCB dcb;
    

34.    int i,r;
    

36.    if(argc<2)
    

37.    {
    

38.        printf("Supply a HEX file name.\n");
    

39.        return;
    

40.    }
    

42.    dev=CreateFile("COM3", GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,  FILE_FLAG_OVERLAPPED,0);
    

43.    if(dev==INVALID_HANDLE_VALUE)
    

44.    {
    

45.        printf("Cannot open COM3 port.\n");
    

46.        exit(1);
    

47.    }
    

48.    FillMemory(&dcb, sizeof(dcb), 0);
    

49.    dcb.DCBlength = sizeof(dcb);
    

50.    BuildCommDCB("57600,n,8,1",&dcb);
    

51.    if (!SetCommState(dev, &dcb))
    

52.    {
    

53.        printf("Cannot set port parameters.\n");
    

54.        exit(1);
    

55.    }
    

56.    oWR.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    

57.    oRD.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    

59.    for(i=0;i<1000;i++)
    

60.    {
    

61.        int len0;
    

62.        char c, buf[32];
    

63.        char done=0;
    

65.        writecomm("?",1);
    

66.        r=readcomm(buf,4,20);
    

67.        if(r>0)
    

68.        {
    

69.            int j;
    

70.            for(j=0;j<r;j++)
    

71.            {
    

72.                printf("%c",buf[j]);
    

73.                if(buf[j]=='S')
    

74.                {
    

75.                    r=readcomm(buf+r,14-(4-j),20);
    

76.                    if(r==14-(4-j) && strncmp(buf+j,"Synchronized\r\n",14)==0)
    

77.                    {
    

78.                        printf("SYNC\n");
    

79.                        writecomm("Synchronized\r\n",14);
    

80.                        r=readcomm(buf,32,50);
    

81.                        if(r==18 && strncmp(buf,"Synchronized\r\nOK\r\n",18)==0)
    

82.                        {
    

83.                            printf("Synchronization done\n");
    

84.                            done=1;
    

85.                            break;
    

86.                        }
    

87.                        else
    

88.                            printf("(%d) %s",r,buf);
    

89.                    }
    

90.                }
    

91.            }
    

92.            if(done) break;
    

93.        }
    

94.        else
    

95.        {
    

96.            printf(".");
    

97.            continue;
    

98.        }
    

99.    }
    

101.    {
     

102.        char c;
     

103.        writecomm("11095\r\n",7);
     

104.        while(readcomm(&c,1,10)>0)
     

105.        {
     

106.            printf("%c",c);
     

107.        }
     

108.    }
     

110.    {
     

111.        char c;
     

112.        writecomm("J\r\n",3);
     

113.        while(readcomm(&c,1,10)>0)
     

114.        {
     

115.            printf("%c",c);
     

116.        }
     

117.    }
     

119.    {
     

120.        unsigned int progaddr=0x40000200;
     

121.        char c;
     

122.        char str[128];
     

123.        char buf[512];
     

124.        int slen;
     

125.        int pgsize;
     

126.        struct ROM rom[1024];
     

127.        int offset=-1;
     

128.        pgsize=loadhexfile(argv[1],1024,&offset,rom);
     

130.        printf("Program Size: %d bytes from %X\n", pgsize, offset);
     

132.        showbinary(1024,rom);
     

134.        sprintf(str,"W %d %d\r\n",progaddr, pgsize);
     

135.        slen=strlen(str);
     

136.        writecomm(str,slen);
     

137.        while(readcomm(&c,1,10)>0)
     

138.        {
     

139.            printf("%c",c);
     

140.        }
     

142.        slen=uuencode(1024, rom, buf, 512, 61);
     

143.        writecomm(buf,slen);
     

144.        sprintf(str,"%d\r\n",checksum(1024,rom));
     

145.        slen=strlen(str);
     

146.        writecomm(str,slen);
     

148.        while(readcomm(&c,1,10)>0)
     

149.        {
     

150.            printf("%c",c);
     

151.        }
     

153.        writecomm("U 23130\r\n",9);
     

154.        while(readcomm(&c,1,10)>0)
     

155.        {
     

156.            printf("%c",c);
     

157.        }
     

159.        sprintf(str,"G %d T\r\n",progaddr);
     

161.        slen=strlen(str);
     

162.        writecomm(str,slen);
     

163.        while(readcomm(&c,1,10)>0)
     

164.        {
     

165.            printf("%c",c);
     

166.        }
     

168.    }
     

170.    CloseHandle(oWR.hEvent);
     

171.    CloseHandle(oRD.hEvent);
     

172.    CloseHandle(dev);
     

174. }
     

178. int writecomm(unsigned char *buf, int len)
     

179. {
     

180.    int r;
     

181.    int len0;
     

183.    r=WriteFile(dev,buf,len,&len0, &oWR);
     

184.    if(r==0)
     

185.    {
     

186.        if(GetLastError()!=ERROR_IO_PENDING)
     

187.        {
     

188.            printf("COM port access error!\n");
     

189.            exit(1);
     

190.        }
     

191.        GetOverlappedResult(dev, &oWR, &len0, TRUE);
     

192.    }
     

193.    return len0;
     

195. }
     

198. int readcomm(unsigned char *buf, int maxlen, int tmout)
     

199. {
     

201.     static unsigned wait=0;
     

202.     static unsigned char ch;
     

203.     int i, len0, r;
     

204.     if(tmout<=0)
     

205.         return 0;
     

207.     for(i=0;i<maxlen;i++)
     

208.     {
     

209.         if(!wait)
     

210.         {
     

211.             if(ReadFile(dev,&ch,1,&len0, &oRD))
     

212.             {
     

213.                 wait=0;
     

214.                 buf[i]=ch;
     

215.                 continue;
     

216.             }
     

217.             if(GetLastError()!=ERROR_IO_PENDING)
     

218.             {
     

219.                 printf("Read COM port error!\n");
     

220.                 exit(1);
     

221.             }
     

222.         }
     

223.         r=WaitForSingleObject(oRD.hEvent,1);
     

224.         if(r==WAIT_TIMEOUT)
     

225.         {
     

226.             wait=1;
     

227.             tmout--;
     

228.             if(tmout==0)
     

229.                 return i;
     

230.             else
     

231.             {
     

232.                 i--;
     

233.                 continue;  
     

234.             }
     

235.         }
     

236.         if(r==WAIT_OBJECT_0)
     

237.         {
     

238.             wait=0;
     

239.             buf[i]=ch;
     

240.             continue;
     

241.         }
     

242.     }
     

243.     return i;
     

244. }
     

248. int loadhexfile(char *fn,int szlimit,int *poff,struct ROM *rom)
     

249. {
     

250.     int i,j,n,count,addr,waddr,bsz;
     

251.     char line[512];
     

252.     unsigned char bb,sum,hex[256];
     

253.     FILE *fp;
     

255.     memset(rom,0,sizeof(struct ROM)*szlimit);
     

257.     fp=fopen(fn,"r");
     

258.     if(fp==NULL)
     

259.     {
     

260.         printf("Cannot open HEX file %s\n",fn);
     

261.         return 0;
     

262.     }
     

263.     printf("Opening file %s for reading... ",fn);
     

265.     count=0;
     

266.     sum=0;
     

267.     for(n=1;;n++)
     

268.     {
     

269.         if(!fgets(line,512,fp))
     

270.             errexit("read error\n");
     

271.         if(line[0]!=':')
     

272.             errexit("FORMAT ERROR\n");
     

273.         j=0;
     

274.         for(i=1;;i+=2)  // convert ASCII to binary
     

275.         {
     

276.             switch(line[i])
     

277.             {
     

278.                 case 'A':  bb=0xa0;  break;
     

279.                 case 'B':  bb=0xb0;  break;
     

280.                 case 'C':  bb=0xc0;  break;
     

281.                 case 'D':  bb=0xd0;  break;
     

282.                 case 'E':  bb=0xe0;  break;
     

283.                 case 'F':  bb=0xf0;  break;
     

284.                 case '\0':  case '\r':  case '\n': bb=0x77;  break;
     

285.                 default:  if(line[i]>='0' && line[i]<='9')
     

286.                               bb=(line[i]-'0')<<4;
     

287.                           else
     

288.                               bb=0xff;
     

289.             }
     

290.             if(bb==0x77)
     

291.                 break;
     

292.             if(bb==0xff)
     

293.                 errexit("INVALID CHARACTER\n");
     

294.             switch(line[i+1])
     

295.             {
     

296.                 case 'A':  bb+=0xa;  break;
     

297.                 case 'B':  bb+=0xb;  break;
     

298.                 case 'C':  bb+=0xc;  break;
     

299.                 case 'D':  bb+=0xd;  break;
     

300.                 case 'E':  bb+=0xe;  break;
     

301.                 case 'F':  bb+=0xf;  break;
     

302.                 default:  if(line[i+1]>='0' && line[i+1]<='9')
     

303.                               bb+=(line[i+1]-'0');
     

304.                           else
     

305.                               errexit("BAD BYTE\n");
     

306.             }
     

307.             sum+=bb;
     

308.             hex[j]=bb;
     

309.             j++;
     

310.         } // converted ASCII to binary
     

311.         if(sum!=0)
     

312.             errexit("CHECKSUM ERROR\n");
     

313.         if(j<5)
     

314.             errexit("LINE TOO SHORT\n");
     

315.         if(hex[0]!=j-5)
     

316.             errexit("FORMAT ERROR\n");
     

317.         bsz=j-5;
     

318.         switch(hex[3])
     

319.         {
     

320.             case 0:   addr=hex[1];   addr<<=8;  addr+=hex[2];
     

321.                       if(*poff==-1)
     

322.                       {
     

323.                           *poff=addr;
     

324.                       }
     

325.                       for(i=0;i<bsz;i++)
     

326.                       {
     

327.                           int waddr=addr-(*poff);
     

328.                           if(waddr>szlimit)
     

329.                           {
     

330.                               printf("address %X beyond range (base %X) \n",addr, *poff);
     

331.                           }
     

332.                           else
     

333.                           {
     

334.                              rom[waddr].b=hex[4+i];
     

335.                              rom[waddr].oc=1;
     

336.                           }
     

337.                           addr++;
     

338.                           count++;
     

339.                       }
     

340.                       break;
     

341.             case 1:   if(j!=5)
     

342.                           errexit("UNEXPECTED END\n");
     

343.                       fclose(fp);
     

344.                       return count;
     

345.             case 2:   if(hex[1]!=0 || hex[2]!=0 || hex[4]!=0 || hex[5]!=0)
     

346.                           printf("UNSUPPORTED PARAGRAPH\n");
     

347.                       break;
     

348.             case 3:
     

349.             default:  printf("UNSUPPORTED RECODE TYPE (%X)\n", hex[3]); break;
     

350.         }
     

351.     }
     

352. }
     

355. int showbinary(int szlimit, struct ROM *rom)
     

356. {
     

357.     int i;
     

358.     for(i=0;i<szlimit;)
     

359.     {
     

360.         int j;
     

361.         char blank=1;
     

363.         for(j=0;j<16;j++)
     

364.         {
     

365.             if(rom[i+j].oc)
     

366.             {
     

367.                 blank=0;
     

368.                 break;
     

369.             }
     

370.         }
     

371.         if(blank)
     

372.         {
     

373.             i+=16;
     

374.             continue;
     

375.         }
     

377.         printf("%04X: ",i);
     

378.         for(j=0;j<16;j++)
     

379.         {
     

380.             if(rom[i+j].oc)
     

381.                 printf("%02X",rom[i+j].b);
     

382.             else
     

383.                 printf("..");
     

384.             if(j==7)
     

385.                 printf(" - ");
     

386.             else
     

387.                 printf(" ");
     

388.         }
     

389.         printf(" | ");
     

390.         for(j=0;j<16;j++)
     

391.         {
     

392.             if(rom[i+j].oc)
     

393.             {
     

394.                 if(rom[i+j].b>=0x20 && rom[i+j].b<=0x7f)
     

395.                     printf("%c",rom[i+j].b);
     

396.                 else
     

397.                     printf("?");
     

398.             }
     

399.             else
     

400.                 printf(".");
     

401.         }
     

403.         i+=16;
     

404.         printf("\n");
     

406.     }
     

407. }
     

410. int uuencode(int szlimit, struct ROM *rom, char *buf, int slen, int linelen)
     

411. {
     

412.     int i, sz=0,mem;
     

413.     int lmax, lc, brem;
     

414.     int index=0;
     

415.     for(i=0;i<szlimit;i++)
     

416.     {
     

417.         if(rom[i].oc)
     

418.             sz=i+1;
     

419.     }
     

420.     lmax=((linelen-1)/4)*3;
     

421.     lc=sz/lmax;
     

422.     brem=sz%lmax;
     

423.     mem=lc*(((linelen-1)/4)*4+3)+3+(brem/3*4)+(brem%3+1);  // include CR LF
     

424.     if(mem>=slen)
     

425.     {
     

426.         printf("UUEncode: buffer too small! need %d bytes\n",mem);
     

427.         return 0;
     

428.     }
     

430.     for(i=0;i<sz;)
     

431.     {
     

432.         int j, len;
     

433.         char r=0;
     

434.         unsigned char b, a=0;
     

436.         if(i+lmax<sz)
     

437.             len=lmax;
     

438.         else
     

439.             len=brem;
     

440.         buf[index++]=0x20+len;
     

441.         for(j=0;j<len;j++)
     

442.         {
     

443.             if(rom[i+j].oc)
     

444.                 b=rom[i+j].b;
     

445.             else
     

446.                 b=0xff;
     

447.             a|=(b>>(2+r));
     

448.             if(a) buf[index++]=0x20+a; else buf[index++]='`';
     

449.             r+=2;
     

450.             a=((b&((1<<r)-1))<<(6-r));
     

451.             if(r==6)
     

452.             {
     

453.                 if(a) buf[index++]=0x20+a; else buf[index++]='`';
     

454.                 r=0;
     

455.                 a=0;
     

456.             }
     

457.         }
     

458.         if(r!=0)
     

459.         {
     

460.             if(a) buf[index++]=0x20+a; else buf[index++]='`';
     

461.         }
     

462.         i+=lmax;
     

463.         buf[index++]='\r';
     

464.         buf[index++]='\n';
     

466.     }
     

468.     printf("MEM %d, actual %d\n",mem,index);
     

469.     return index;
     

470. }
     

473. int checksum(int szlimit, struct ROM *rom)
     

474. {
     

475.     int i, sz, sum;
     

476.     sz=0;
     

477.     for(i=0;i<szlimit;i++)
     

478.     {
     

479.         if(rom[i].oc)
     

480.             sz=i+1;
     

481.     }
     

482.     sum=0;
     

483.     for(i=0;i<sz;i++)
     

484.         sum+=rom[i].b;
     

485.     return sum;
     

486. }

复制代码

这个程序做的工作是打开串口, 和单片机Bootloader ISP命令同步，然后读取指定的HEX文件，下载到LPC2220的RAM地址 0x40000200, 再解除锁定，最后发送执行程序的命令，单片机从 0x40000200 开始运行。如果要重新下载程序，把单片机Reset了，再运行以上的程序即可。命令行一步搞定，容易吧！

注: LPC2220的RAM地址从 0x40000000 开始，但是BootLoader会用一部分RAM，所以为了避免冲突，程序下载从RAM的512字节之后起。NXP的Bootloader是用UUEncode编码传输二进制数据的，上面的程序包含编码的子程序。这个程序也写得不完善，还有比如代码长度检查都没有做进去，目前做到的只是能下载一小段并执行。