树莓派BootLoader（转载）

树老大

made by Rk
本文由浙江大学《嵌入式系统》课程提供强力支持。
感谢翁恺老师 @翁恺BA5AG
/*************************************************************/

实验内容：David Welch的GitHub的 bootloader05给出了一个非常简单的RPi bootloader，他的代码链接在内存的0x00020000位置，一直在监听串口是 否有XMODEM协议的文件下载，如果有就开始接收数据，并复制到0x00008000位置，传输完成后跳转到 0x00008000去执行。
TA写了一个Python脚本，按照下面的命令调用脚本可以下载并执行用户程序


python xmodem-loader.py -p com3 -baud 115200 output.bin
你的任务是修改bootloader和python脚本实现如下功能：


调用命令 python xmodem-loader.py -p com3 -baud 115200 启动脚本并且与板卡建立串口连接，之后可以发送下面的命令。
load *.bin 下载程序*.bin
go 执行已下载的程序
peek addr 以一个字为单位读取内存中addr位置的数据（addr是4字节对齐，十六进行的形式，长度为8，例如 0x00008000），并以十六进制的形式输出
poke addr data 以一个字为单位修改内存中addr位置的数据为data（addr是4字节对齐，十六进行的形式，长 度为8， data也是十六进行的形式，长度为8）
verify *.bin 验证已下载的程序和*.bin是否完全相同。

背景在国外大神的README中介绍了相关背景：
This repo serves as a collection of low level examples.  No operating
system, embedded or low level embedded or deeply embedded or bare metal,
whatever your term is for this.
介绍了教程来源

I am in no way shape or form associated with the raspberry pi organization
nor broadcom.  I just happen to own one (some) and am sharing my
experiences.  The raspberry pi is about education, and I feel low
level education is just as important as Python programming.
介绍了作者对于树莓派的想法

From what we know so far there is a gpu on chip which:

1) boots off of an on chip rom of some sort
2) reads the sd card and looks for additional gpu specific boot files
bootcode.bin and start.elf in the root dir of the first partition
(fat32 formatted, loader.bin no longer used/required)
3) in the same dir it looks for config.txt which you can do things like
change the arm speed from the default 700MHz, change the address where
to load kernel.img, and many others
4) it reads kernel.img the arm boot binary file and copies it to memory
5) releases reset on the arm such that it runs from the address where
the kernel.img data was written
树莓派通过板上的GPU加载启动信息，
1、读取SD卡第一个分区根目录里面的bootcode二进制文件以及start.elf。
2、在同一个目录下加载系统配置文件，比如配置CPU主频等，然后切换到读取kernel.img的地址。
3、读取kelnel后加载ARM启动二进制文件然后拷贝到内存，发送重置信号，使得树莓派可以从kernel.img的写入数据区开始加载命令继续执行。

The memory is split between the GPU and the ARM, I believe the default
is to split the memory in half.  And there are ways to change that
split (to give the ARM more).  Not going to worry about that here.

内存被分为GPU和ARM使用两部分，目测对半分。

From the ARMs perspective the kernel.img file is loaded, by default,
to address 0x8000.  (there are ways to change that, not going to worry
about that right now).
从ARM的角度来看，kernel镜像从地址0x8000开始加载。

Hardware and programming information:


You will want to go here
http://elinux.org/RPi_Hardware
And get the datasheet for the part
http://www.raspberrypi.org/wp-co ... ARM-Peripherals.pdf
(might be an old link, find the one on the wiki page)
And the schematic for the board
http://www.raspberrypi.org/wp-co ... Schematics-R1.0.pdf
(might be an old link, find the one on the wiki page)


Early in the BCM2835 document you see a memory map.  I am going to
operate based on the middle map, this is how the ARM comes up.  The
left side is the system which we dont have direct access to in that
form, the gpu probably, not the ARM.  The ARM comes up with a memory
space that is basically 0x40000000 bytes in size as it mentions in
the middle chart.  The bottom of this picture shows total system
sdram (memory) and somewhere between zero and the top of ram is a
split between sdram for the ARM on the bottom and a chunk of that
for the VC SDRAM, basically memory for the gpu and memory shared
between the ARM and GPU to allow the ARM to ask the GPU to draw stuff
on the video screen.  256MBytes is 0x10000000, and 512MBytes is
0x20000000.  Some models of raspberry pi have 256MB, newer models have
512MB total ram which is split between the GPU and the ARM.  Assume
the ARM gets at least half of this.  Peripherals (uart, gpio, etc)
are mapped into arm address space at 0x20000000.  When you see
0x7Exxxxxx in the manual replace that with 0x20xxxxxx as your ARM
physical address.  Experimentally I have seen the memory repeats every
0x40000000, read 0x40008000 and you see the data from 0x8000.  I
wouldnt rely on this, just an observation (likely ignoring the upper
address bits in the memory controller).
第一次编译运行
在Mac系统上的编译一开始遇到一些问题，需要修改loader文件为以下内容：

1. MEMORY
   
2. {
   
3.     ram : ORIGIN = 0x8000, LENGTH = 0x1000000
   
4. }
   
5. 
   
6. SECTIONS
   
7. {
   
8.     .text : { *(.text*) *(.rodata.str1.4) *(.rodata) } > ram
   
9.     .bss : { *(.bss*) } > ram
   
10. }

复制代码

修改bootloader05.c文件，原理是：
将原有的3个控制状态和128个数据读写状态修改为7个控制状态以及128个数据读写状态。
其中新增的状态有：
1、GO状态，跳转到Base Address读取并且执行代码；
2、Verify状态，根据error address的不同进行检查，error address初始化为0，一旦在verify过程中检查到已读到的数据与新的bin文件不一致，记录当前错误地址，并且回到状态0；
3、Peek状态，根据后面指令输入的address，通过GET（address）函数（定义在vector.s中）得到该内存地址上存的值，打印输出；
4、Poke状态，根据指令后面的地址以及新的数据，通过PUT（address，data value）函数（定义在vector.s中）修改内存地址，并且打印输出修改地址和修改后的值（通过GET得到）
5、LOAD状态，也就是加载二进制文件。

源代码中检查block块有两次检验，个人感觉第二次可以去掉，于是尝试了一下，事实证明也是可以的。

代码以及注释如下：

1. //-------------------------------------------------------------------------
   
2. //-------------------------------------------------------------------------
   
3. 
   
4. // The raspberry pi firmware at the time this was written defaults
   
5. // loading at address 0x8000.  Although this bootloader could easily
   
6. // load at 0x0000, it loads at 0x8000 so that the same binaries built
   
7. // for the SD card work with this bootloader.  Change the ARMBASE
   
8. // below to use a different location.
   
9. 
   
10. #define ARMBASE 0x8000
    
11. #define true 1
    
12. 
    
13. #define LOAD    0x00
    
14. #define GO      0x01
    
15. #define PEEK    0x02
    
16. #define POKE    0x03
    
17. #define VERIFY  0x04
    
18. 
    
19. extern void PUT32 ( unsigned int, unsigned int );
    
20. extern void PUT16 ( unsigned int, unsigned int );
    
21. extern void PUT8 ( unsigned int, unsigned int );
    
22. extern unsigned int GET32 ( unsigned int );
    
23. extern unsigned int GET8 ( unsigned int );
    
24. extern unsigned int GETPC ( void );
    
25. extern void BRANCHTO ( unsigned int );
    
26. extern void dummy ( unsigned int );
    
27. 
    
28. extern void uart_init ( void );
    
29. extern unsigned int uart_lcr ( void );
    
30. extern void uart_flush ( void );
    
31. extern void uart_send ( unsigned int );
    
32. extern unsigned int uart_recv ( void );
    
33. extern void hexstring ( unsigned int );
    
34. extern void hexstrings ( unsigned int );
    
35. extern void timer_init ( void );
    
36. extern unsigned int timer_tick ( void );
    
37. 
    
38. extern void timer_init ( void );
    
39. extern unsigned int timer_tick ( void );
    
40. 
    
41. void print_pi(char* s) {
    
42.     int i = 0;
    
43.     while(s[i] != '\0') {
    
44.         uart_send(s[i++]);
    
45.     }
    
46.     uart_send(0x0D);    //send carriage return
    
47.     uart_send(0x0A);    //send new line
    
48. }
    
49. 
    
50. //------------------------------------------------------------------------
    
51. unsigned char xstring[256];
    
52. //------------------------------------------------------------------------
    
53. int notmain ( void ) {
    
54.     unsigned int ra;
    
55.     //unsigned int rb;
    
56.     unsigned int rx;
    
57.     unsigned int addr;
    
58.     unsigned int block;
    
59.     unsigned int state;
    
60. 
    
61.     unsigned int crc;
    
62.     unsigned int error_addr;
    
63. 
    
64.     uart_init();            //init serial
    
65.     hexstring(0x12345678);  //translate to hex value and send
    
66.     hexstring(GETPC());
    
67.     hexstring(ARMBASE);
    
68.     print_pi("This is Raspberry Pi!");
    
69.     uart_send(0x04);
    
70.     timer_init();
    
71. 
    
72. //SOH 0x01
    
73. //ACK 0x06
    
74. //NAK 0x15
    
75. //EOT 0x04
    
76. 
    
77. //block numbers start with 1
    
78. 
    
79. //132 byte packet
    
80. //starts with SOH
    
81. //block number byte
    
82. //255-block number
    
83. //128 bytes of data
    
84. //checksum byte (whole packet)
    
85. //a single EOT instead of SOH when done, send an ACK on it too
    
86.    
    
87.     addr=ARMBASE;        //base RAM address
    
88.     error_addr = 0; //record the address of error
    
89.     block=1;        //the
    
90.     state=0;                //initial state
    
91.     crc=0;          //check sum
    
92.     rx=timer_tick();
    
93. 
    
94.     while(true)
    
95.     {
    
96.         ra=timer_tick();
    
97.         if((ra-rx)>=4000000)
    
98.         {
    
99.             uart_send(0x15);                //send long time no-response signal
    
100.             rx+=4000000;
     
101.         }
     
102. 
     
103.         if((uart_lcr()&0x01)==0)
     
104.         {
     
105.             continue;               //test if input string begin with 0x01
     
106.         }
     
107. 
     
108.         xstring[state]=uart_recv();
     
109.         rx=timer_tick();
     
110. 
     
111.         switch(state)
     
112.         {
     
113.             case 0:     //initial state, decide which action to take
     
114.             {
     
115.                 if(xstring[state]==0x01)
     
116.                 {
     
117.                     crc=xstring[state];
     
118.                     state++;
     
119.                 }
     
120.                 else if (xstring[state] == 0x04)    //End Of transmission
     
121.                 {                                   //decide the action
     
122.                     uart_send(0x06);
     
123.                     if (xstring[1] == LOAD)
     
124.                     {
     
125.                         print_pi("This is LOAD command!");
     
126.                         uart_send(0x04);
     
127.                         uart_flush();
     
128.                     }
     
129.                     else if (xstring[1] == VERIFY)
     
130.                     {
     
131.                         if (error_addr == 0)
     
132.                         {
     
133.                             print_pi("Verify successful!");
     
134.                             uart_send(0x04);
     
135.                         }
     
136.                         else
     
137.                         {
     
138.                             print_pi("Verify error");
     
139.                             print_pi("Error Adress:");
     
140.                             hexstring(error_addr);
     
141.                             print_pi("Error Value:");
     
142.                             hexstring(GET32(error_addr));
     
143.                             uart_send(0x04);
     
144.                         }
     
145.                         uart_flush();
     
146.                     }
     
147.                     addr = ARMBASE;
     
148.                     error_addr = 0;
     
149.                     block = 1;
     
150.                     state = 0;
     
151.                     crc = 0;
     
152.                 }
     
153.                 else
     
154.                 {
     
155.                     state=0;
     
156.                     uart_send(0x15);
     
157.                     print_pi("Init Error!");
     
158.                     uart_send(0x04);
     
159.                     uart_flush();
     
160.                 }
     
161.                 break;
     
162.             }
     
163.             case 1:                             //decide the action
     
164.             {
     
165.                 if (xstring[1] > VERIFY)
     
166.                 {
     
167.                     state = 0;
     
168.                     uart_send(0x15);
     
169.                     print_pi("Command error!");
     
170.                     uart_send(0x04);
     
171.                     uart_flush();
     
172.                 }
     
173.                 else if (xstring[1] == GO)
     
174.                 {
     
175.                     state = 0;
     
176.                     uart_send(0x06);
     
177.                     print_pi("Branch to the base address!");
     
178.                     uart_send(0x04);
     
179.                     uart_flush();
     
180.                     BRANCHTO(ARMBASE);
     
181.                 }
     
182.                 else if (xstring[1] == PEEK)
     
183.                 {
     
184.                     state = 133;
     
185.                 }
     
186.                 else if (xstring[1] == POKE)
     
187.                 {
     
188.                     state = 133;
     
189.                 }
     
190.                 else
     
191.                 {
     
192.                     state++;
     
193.                 }
     
194.                 break;
     
195.             }
     
196.             case 2:
     
197.             {
     
198.                 if(xstring[state] == block)//if the data has the right block number
     
199.                 {
     
200.                     crc += xstring[state];
     
201.                     state++;
     
202.                 }
     
203.                 else
     
204.                 {
     
205.                     state = 0;
     
206.                     uart_send(0x15);
     
207.                     print_pi("Data block error!");
     
208.                     uart_send(0x04);
     
209.                     uart_flush();
     
210.                 }
     
211.                 break;
     
212.             }
     
213.             
     
214.             case 132:   //receive and verify progress
     
215.             {
     
216.                 crc &= 0xFF;
     
217.                 if(xstring[state]==crc)
     
218.                 {
     
219.                     if (xstring[1] == LOAD)
     
220.                     {
     
221.                         for(ra=0; ra<128; ra++)
     
222.                         {
     
223.                             PUT8(addr++,xstring[ra+4]);
     
224.                         }
     
225.                         uart_send(0x06);
     
226.                     }
     
227.                     else
     
228.                     {
     
229.                         //Verify progress
     
230.                         for (ra=0; ra<128; ra++,addr++)
     
231.                         {
     
232.                             if (xstring[ra + 4] != (GET8(addr) & 0xff))
     
233.                             {
     
234.                                 error_addr = addr;  //get the error address
     
235.                                 break;
     
236.                             }
     
237.                         }
     
238.                         uart_send(0x06);
     
239.                     }
     
240.                     block=(block+1) & 0xFF; //if the data flow has not stopped
     
241.                 }
     
242.                 else
     
243.                 {
     
244.                     uart_send(0x15);
     
245.                     print_pi("Check sum error!");
     
246.                     uart_send(0x04);
     
247.                     uart_flush();
     
248.                 }
     
249.                 state=0;
     
250.                 break;
     
251.             }
     
252.             case 136:
     
253.             {
     
254.                 if (xstring[1] == PEEK)
     
255.                 {
     
256.                     unsigned int peek_addr = 0;
     
257.                     for (ra = 0; ra < 4; ra++)
     
258.                     {   //generate the address
     
259.                         peek_addr = peek_addr << 8 | xstring[ra + 133];
     
260.                     }
     
261.                     uart_send(0x06);
     
262.                     print_pi("Peek command value:");
     
263.                     hexstring(GET32(peek_addr));
     
264.                     uart_send(0x04);
     
265.                     uart_flush();
     
266.                     state = 0;
     
267.                 }
     
268.                 else
     
269.                 {
     
270.                     state++;
     
271.                 }
     
272.                 break;
     
273.             }
     
274.             case 140:
     
275.             {
     
276.                 if (xstring[1] == POKE)
     
277.                 {
     
278.                     unsigned int poke_addr = 0x00000000;
     
279.                     unsigned int poke_data = 0;
     
280.                     for (ra = 0; ra < 4; ra++)
     
281.                     {
     
282.                         poke_addr = poke_addr << 8 | xstring[ra + 133];
     
283.                         poke_data = poke_data << 8 | xstring[ra + 137];
     
284.                     }
     
285.                     uart_send(0x06);
     
286.                     print_pi("Poke command:");
     
287.                     PUT32(poke_addr, poke_data);
     
288.                     print_pi("Poke address:");
     
289.                     hexstring(poke_addr);           //get the Poke address
     
290.                     print_pi("Poke value:");
     
291.                     hexstring(GET32(poke_addr));   //get the value after edit action
     
292.                     uart_send(0x04);
     
293.                     uart_flush();
     
294.                     state = 0;
     
295.                 }
     
296.                 else
     
297.                 {
     
298.                     state = 0;
     
299.                 }
     
300.                 break;
     
301.             }
     
302.             default:
     
303.             {
     
304.                 crc+=xstring[state];
     
305.                 state++;
     
306.                 break;
     
307.             }
     
308.         }
     
309.     }
     
310.     return(0);
     
311. }
     
312. 
     
313. //-------------------------------------------------------------------------
     
314. //-------------------------------------------------------------------------
     
315. 
     
316. 
     
317. //-------------------------------------------------------------------------
     
318. //
     
319. // Copyright (c) 2012 David Welch dwelch@dwelch.com
     
320. //
     
321. // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
     
322. //
     
323. // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
     
324. //
     
325. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     
326. //
     
327. //-------------------------------------------------------------------------
     

复制代码

在vector.s中增加GET8：

1. .globl GET8
   
2. GET8:
   
3.     ldrb r0,[r0]
   
4.     bx lr

复制代码

修改py文件对串口数据进行操作：

1. import sys, getopt
   
2. import serial
   
3. import time
   
4. 
   
5. def open(aport='/dev/tty.usbserial', abaudrate=115200) :#此处修改为本机串口地址，可以参见博文 http://blog.csdn.net/rk2900/article/details/8632713
   
6.   return serial.Serial(
   
7.       port=aport,
   
8.       baudrate=abaudrate,     # baudrate
   
9.       bytesize=8,             # number of databits
   
10.       parity=serial.PARITY_NONE,
    
11.       stopbits=1,
    
12.       xonxoff=0,              # enable software flow control
    
13.       rtscts=0,               # disable RTS/CTS flow control
    
14.       timeout=None               # set a timeout value, None for waiting forever
    
15.   )
    
16. 
    
17. def printLog(sp):
    
18.   temp = sp.read()
    
19.   while ord(temp) != 0x04:
    
20.       write(temp)
    
21.       temp = sp.read()
    
22. 
    
23. if __name__ == "__main__":
    
24. 
    
25.   # Import Psyco if available
    
26.   try:
    
27.       import psyco
    
28.       psyco.full()
    
29.       print "Using Psyco..."
    
30.   except ImportError:
    
31.       pass
    
32. 
    
33.   conf = {
    
34.       'port': '/dev/tty.usbserial',#此处修改为本机串口地址
    
35.       'baud': 115200,
    
36.   }
    
37. 
    
38.   try:
    
39.       opts, args = getopt.getopt(sys.argv[1:], "hqVewvrp:b:a:l:")
    
40.   except getopt.GetoptError, err:
    
41.       print str(err)
    
42.       sys.exit(2)
    
43. 
    
44.   for o, a in opts:
    
45.       if o == '-p':
    
46.           conf['port'] = a
    
47.       elif o == '-b':
    
48.           conf['baud'] = eval(a)
    
49.       else:
    
50.           assert False, "option error!"
    
51. 
    
52.   sp = open(conf['port'], conf['baud'])
    
53. 
    
54. # print args[0]
    
55. # print conf['port']
    
56. # print conf['baud']
    
57. 
    
58.   write=sys.stdout.write
    
59. 
    
60.   isLoaded = False
    
61. 
    
62.   while True:
    
63.       print ''
    
64.       cmd = raw_input('>> ').split(' ');
    
65.       sp.flushInput()
    
66. 
    
67.       if cmd[0] == 'go':
    
68.           if not isLoaded:
    
69.               confirm = raw_input("No file loaded, sure to go? [Y/N]")
    
70.               if confirm == '' or confirm[0] == 'N' or confirm[0] == 'n':
    
71.                   continue
    
72. 
    
73.           success = False
    
74.           while success == False:
    
75.               sp.write(chr(0x01))
    
76.               sp.write(chr(0x01))
    
77.               sp.flush()
    
78. 
    
79.               temp=sp.read()
    
80. 
    
81.               if ord(temp)==0x06:
    
82.                   success = True
    
83.               else:
    
84.                   print ord(temp)
    
85. 
    
86.                   printLog(sp)
    
87. 
    
88.       elif cmd[0] == 'peek':
    
89.           if len(cmd) < 2:
    
90.               print "Incorrect command, should be 'peek addr'"
    
91.               continue
    
92. 
    
93.           addr = int(cmd[1], 16) & 0xffffffff
    
94. 
    
95.           success = False
    
96.           while success == False:
    
97.               sp.write(chr(0x01))
    
98.               sp.write(chr(0x02))
    
99. 
    
100.               for i in range(0,4):
     
101.                   sp.write(chr(addr >> 24 & 0xff))
     
102.                   addr = addr << 8
     
103. 
     
104.               sp.flush()
     
105. 
     
106.               temp=sp.read()
     
107. 
     
108.               if ord(temp)==0x06:
     
109.                   success = True
     
110.               else:
     
111.                   print ord(temp)
     
112. 
     
113.                   printLog(sp)
     
114. 
     
115.       elif cmd[0] == 'poke':
     
116.           if len(cmd) < 3:
     
117.               print "Incorrect command, should be 'poke addr data'"
     
118.               continue
     
119. 
     
120.           addr = int(cmd[1], 16) & 0xffffffff
     
121.           data = int(cmd[2], 16) & 0xffffffff
     
122. 
     
123.           success = False
     
124.           while success == False:
     
125.               sp.write(chr(0x01))
     
126.               sp.write(chr(0x03))
     
127. 
     
128.               for i in range(0,4):
     
129.                   sp.write(chr(addr >> 24 & 0xff))
     
130.                   addr = addr << 8
     
131.               for i in range(0,4):
     
132.                   sp.write(chr(data >> 24 & 0xff))
     
133.                   data = data << 8
     
134. 
     
135.               sp.flush()
     
136. 
     
137.               temp=sp.read()
     
138. 
     
139.               if ord(temp)==0x06:
     
140.                   success = True
     
141.               else:
     
142.                   print ord(temp)
     
143. 
     
144.                   printLog(sp)
     
145. 
     
146.       elif cmd[0] == 'load' or cmd[0] == 'verify':
     
147.           if len(cmd) < 2:
     
148.               print "Please input the filename"
     
149.               continue
     
150. 
     
151.           try:
     
152.               data = map(lambda c: ord(c), file(cmd[1],"rb").read())
     
153.           except:
     
154.               print "File path error"
     
155.               continue
     
156. 
     
157.           temp = sp.read()
     
158.           buf = ""
     
159. 
     
160.           dataLength = len(data)
     
161.           blockNum = (dataLength-1)/128+1
     
162.           print "The size of the image is ",dataLength,"!"
     
163.           print "Total block number is ",blockNum,"!"
     
164.           print "Download start,",blockNum,"block(s) in total!"
     
165. 
     
166.           for i in range(1,blockNum+1):
     
167.               success = False
     
168.               while success == False:
     
169.                   sp.write(chr(0x01))
     
170.                   if cmd[0] == 'load':
     
171.                       sp.write(chr(0x00))
     
172.                   else:
     
173.                       sp.write(chr(0x04))
     
174.                   sp.write(chr(i&0xFF))
     
175.                   sp.write(chr(0xFF-i&0xFF))
     
176.                   crc = 0x01+0xFF
     
177. 
     
178.                   for j in range(0,128):
     
179.                       if len(data)>(i-1)*128+j:
     
180.                           sp.write(chr(data[(i-1)*128+j]))
     
181.                           crc += data[(i-1)*128+j]
     
182.                       else:
     
183.                           sp.write(chr(0xff))
     
184.                           crc += 0xff
     
185. 
     
186.                   crc &= 0xff
     
187.                   sp.write(chr(crc))
     
188.                   sp.flush()
     
189. 
     
190.                   temp=sp.read()
     
191.                   sp.flushInput()
     
192. 
     
193.                   if ord(temp)==0x06:
     
194.                       success = True
     
195.                       print "Block",i,"has finished!"
     
196.                   else:
     
197.                       print ord(temp)
     
198.                       print "Error,send again!"
     
199. 
     
200.                       printLog(sp)
     
201. 
     
202.           sp.write(chr(0x04))
     
203.           sp.flush()
     
204.           temp=sp.read()
     
205. 
     
206.           if ord(temp)==0x06:
     
207.               if (cmd[0] == 'load'):
     
208.                   isLoaded = True
     
209.               print "Download has finished!\n"
     
210.       elif cmd[0] == 'q':
     
211.           sys.exit(0)
     
212.       else:
     
213.           print "Invalid command!"
     
214. 
     
215. 
     
216.       printLog(sp)
     
217. 
     
218. 
     
219.   # while True:
     
220.   #   write(sp.read())
     
221. 
     
222.   sp.close()

复制代码

实验结果LOAD指令：



输入GO指令，此处我加载的是外国人搞的blinker二进制文件，效果就是树莓派上ACT的小灯闪烁。
效果如图：


进行PEEK与POKE操作
此处POKE将修改后的内存值打印出来是需要通过GET操作得到后来该内存地址处的值，而非打印POKE操作输入的参数。

POKE操作之前进行Verify：

POKE操作之后进行verify：

转载自：http://blog.csdn.net/rk2900/article/details/8936580

htbadboy

脚印了，感谢分享