LGT的基本写入/读出已经分析完成，下个星期回家后分析FUSE

xwkm

这里仅仅是一个实例程序。用计数值填充LGT的整个FLASH空间的程序。现在已经做好串口ISP，可以上马/自制脱机编程器了。只是熔丝会有点稍稍的麻烦。
这个是51代码。但是事实上只要更换IO操作函数是可以在别的机器上用的。
Test函数中有说明如何写入。
感谢bbsniua网友和goodcode的ISP（反汇编+逻辑分析仪发现退出编程的命令有点问题）以及官方ISP程序。
等到下次回家以后搞定熔丝位。毕竟现在熔丝位看起来很奇怪。貌似不是以明文形式表示的OSCCAL。
OK废话少说上代码：

1. #include <hwconfig.h>//包含硬件配置
   
2. #include <type-def.h>//包含一些定义
   
3. 
   
4. BYTE OutBuf[5];//发送命令缓冲
   
5. BYTE InBuf[5];//接收缓冲
   
6. //BYTE ComBuf[36];// |SOT|CMD|Data(32bytes)|ChkSum|EOT|
   
7. void SendSPI(BYTE nByte)//用MOSI串行发送命令的同时用MISO接收相关数据
   
8. {
   
9.         BYTE n;
   
10.         for(n=0;n<nByte;n++)//发送nByte个字节
    
11.         {
    
12.                 //RESET=0;
    
13.                 ACC=OutBuf[n];
    
14.                 SCLK=0;
    
15.                 MOSI=A_7;//低电平时输出一位
    
16.                 SCLK=1;
    
17.                 B_7=MISO;//高电平时接收一位
    
18.                 SCLK=0;
    
19.                 MOSI=A_6;
    
20.                 SCLK=1;
    
21.                 B_6=MISO;
    
22.                 SCLK=0;
    
23.                 MOSI=A_5;
    
24.                 SCLK=1;
    
25.                 B_5=MISO;
    
26.                 SCLK=0;
    
27.                 MOSI=A_4;
    
28.                 SCLK=1;
    
29.                 B_4=MISO;
    
30.                 SCLK=0;
    
31.                 MOSI=A_3;
    
32.                 SCLK=1;
    
33.                 B_3=MISO;
    
34.                 SCLK=0;
    
35.                 MOSI=A_2;
    
36.                 SCLK=1;
    
37.                 B_2=MISO;
    
38.                 SCLK=0;
    
39.                 MOSI=A_1;
    
40.                 SCLK=1;
    
41.                 B_1=MISO;
    
42.                 SCLK=0;
    
43.                 MOSI=A_0;
    
44.                 SCLK=1;
    
45.                 B_0=MISO;
    
46.                 SCLK=0;
    
47.                 InBuf[n]=B;
    
48.                 //RESET=1;
    
49.         }
    
50. }
    
51. void Delay(BYTE n)
    
52. {//不精确延时
    
53.         while(n--);
    
54. }
    
55. 
    
56. 
    
57. BOOL CheckAck() //检查
    
58. {
    
59.         if(InBuf[3]!=0x55) return FALSE;
    
60.         if(InBuf[4]!=0xAA) return FALSE;
    
61.         return TRUE;
    
62. }
    
63. 
    
64. BOOL Reset_Target()
    
65. {//重启目标
    
66.         SCLK=0;
    
67.         MOSI=0;
    
68.         MISO=1;
    
69.         Delay(1);
    
70.         RESET=0;
    
71.         Delay(255);
    
72.         OutBuf[0]=0xE0;//开启编程
    
73.         OutBuf[1]=0x5A;
    
74.         OutBuf[2]=0xA5;
    
75.         OutBuf[3]=0xAA;
    
76.         OutBuf[4]=0x00;
    
77.         SendSPI(5);//发送数据
    
78.         if(InBuf[4]!=0x5A) return FALSE;
    
79.         return TRUE;
    
80. }
    
81. 
    
82. void Read_8F08(BYTE Bank,BYTE Addr)
    
83. {
    
84.         OutBuf[0]=0xB8;
    
85.         OutBuf[1]=Addr;
    
86.         OutBuf[2]=Bank;
    
87.         OutBuf[3]=0x00;
    
88.         OutBuf[4]=0x00;
    
89.         SendSPI(5);
    
90.         OutBuf[0]=0xBC;
    
91.         SendSPI(5);       
    
92.         //And you got it in InBuf[3],InBuf[4]
    
93. }
    
94. 
    
95. 
    
96. BOOL Write_8F08(BYTE Bank,BYTE Addr)
    
97. {
    
98.         OutBuf[0]=0x90;
    
99.         OutBuf[1]=0xC0 | Addr ;//B1000 0000 Or Addr
    
100.         OutBuf[2]=Bank;
     
101.         //OutBuf[3]
     
102.         //OutBuf[4]//送入数据
     
103.         SendSPI(5);
     
104.         if(!CheckAck()) return FALSE;
     
105.         OutBuf[0]=0x98;
     
106.         SendSPI(5);               
     
107.         if(!CheckAck()) return FALSE;
     
108.         OutBuf[0]=0x90;
     
109.         SendSPI(5);
     
110.         if(!CheckAck()) return FALSE;
     
111.         return TRUE;
     
112. }
     
113. 
     
114. BOOL Erase_8F08()
     
115. {
     
116.        
     
117.                 OutBuf[0]=0xB8;
     
118.                 OutBuf[1]=0x3F;
     
119.                 OutBuf[2]=0x07;
     
120.                 OutBuf[3]=0x00;
     
121.                 OutBuf[4]=0x00;
     
122.                 SendSPI(5);
     
123.                
     
124.                 OutBuf[0]=0xBC;
     
125.                 SendSPI(5);
     
126.                
     
127.                 OutBuf[0]=0xA0;
     
128.                 OutBuf[1]=0x00;
     
129.                 OutBuf[2]=0x00;               
     
130.                 SendSPI(5);
     
131.                 Delay(10);
     
132.                 //清除标志位，RDY
     
133.        
     
134.         //----EARSE               
     
135.         OutBuf[0]=0x93;
     
136.         OutBuf[1]=0x00;
     
137.         OutBuf[2]=0x00;
     
138.         OutBuf[3]=0x00;
     
139.         OutBuf[4]=0x00;
     
140.         SendSPI(5);
     
141.         if(!CheckAck()) return FALSE;       
     
142.         OutBuf[1]=0x40;
     
143.         SendSPI(5);
     
144.         if(!CheckAck()) return FALSE;       
     
145.         Delay(255);Delay(255);Delay(255);Delay(255);
     
146.         OutBuf[0]=0x91;
     
147.         SendSPI(5);
     
148.         if(!CheckAck()) return FALSE;       
     
149.         OutBuf[1]=0x00;
     
150.         SendSPI(5);
     
151.         if(!CheckAck()) return FALSE;       
     
152.         OutBuf[0]=0x80;
     
153.         SendSPI(5);
     
154.         if(!CheckAck()) return FALSE;       
     
155.         Delay(255);//保险延时
     
156.         return TRUE;
     
157. }
     
158. 
     
159. BOOL Prep_W8F08(BYTE Bank,BYTE Addr)
     
160. {
     
161.         /*MOSI 90 80 00 00 00
     
162.         MISO AA AA AA 55 AA
     
163.         MOSI 90 C0 00 00 00
     
164.         MISO AA AA AA 55 AA*/
     
165.         OutBuf[0]=0x90;
     
166.         OutBuf[1]=0x80 | Addr;
     
167.         OutBuf[2]=Bank;
     
168.         OutBuf[3]=0x00;
     
169.         OutBuf[4]=0x00;
     
170.         SendSPI(5);
     
171.         if(!CheckAck()) return FALSE;       
     
172.         //OutBuf[0]=0x90;
     
173.         OutBuf[1]=0xC0 | Addr;
     
174.         SendSPI(5);
     
175.         if(!CheckAck()) return FALSE;
     
176.         return TRUE;       
     
177. }
     
178. 
     
179. BOOL Stop_W8F08(BYTE Bank,BYTE Addr)
     
180. {
     
181.         /*MOSI 90 80 00 00 00
     
182.         MISO AA AA AA 55 AA
     
183.         MOSI 90 C0 00 00 00
     
184.         MISO AA AA AA 55 AA*/
     
185.         OutBuf[0]=0x90;
     
186.         OutBuf[1]=Addr | 0x40;
     
187.         OutBuf[2]=Bank;
     
188.         //OutBuf[3]=0x00;
     
189.         //OutBuf[4]=0x00;
     
190.         SendSPI(5);
     
191.         if(!CheckAck()) return FALSE;       
     
192.         //OutBuf[0]=0x90;
     
193.         OutBuf[1]=Addr;
     
194.         SendSPI(5);
     
195.         if(!CheckAck()) return FALSE;
     
196.         OutBuf[0]=0x80;
     
197.         SendSPI(5);
     
198.         if(!CheckAck()) return FALSE;
     
199.         return TRUE;       
     
200. }
     
201. 
     
202. void Stop_R8F08()
     
203. {
     
204.         OutBuf[0]=0xA0;
     
205.         OutBuf[1]=0x00;
     
206.         OutBuf[2]=0x00;
     
207.         OutBuf[3]=0x00;
     
208.         OutBuf[4]=0x00;
     
209.         SendSPI(5);
     
210. }
     
211. 
     
212. void Test()
     
213. {
     
214.         BYTE addr,page,cyc,test=0;
     
215.         if(!Reset_Target()) return;
     
216.        
     
217.                 OutBuf[0]=0xE5;
     
218.                 OutBuf[1]=0x53;
     
219.                 OutBuf[2]=0x35;
     
220.                 OutBuf[3]=0x5E;
     
221.                 OutBuf[4]=0x00;
     
222.                 SendSPI(5);
     
223.                 SendSPI(5);
     
224.                 //写8K
     
225.         /*       
     
226.                 if(!Erase_8F08()) return;
     
227.                 Delay(100);
     
228.                 for(page=0;page<=0x7F;page++)
     
229.                 {//
     
230.                         for(cyc=0;cyc<8;cyc++)
     
231.                         {
     
232.                                 addr=0;
     
233.                                 if(!Prep_W8F08(page,cyc*4)) return;
     
234.                                 for(;addr<4;addr++)
     
235.                                 {
     
236.                                         OutBuf[3]=test+1;
     
237.                                         OutBuf[4]=test;
     
238.                                         test+=2;
     
239.                                         if(!Write_8F08(page,cyc*4+addr)) return;
     
240.                                 }
     
241.                                 addr--;
     
242.                                 if(!Stop_W8F08(page,cyc*4+addr)) return;
     
243.                                 Delay(255);
     
244.                         }
     
245.                         Delay(255);
     
246.                 }
     
247.                 Delay(255);
     
248.                 */
     
249.         Delay(255);Delay(255);Delay(255);Delay(255);
     
250.         Delay(255);Delay(255);Delay(255);Delay(255);
     
251.         Delay(255);Delay(255);Delay(255);Delay(255);
     
252.         Delay(255);Delay(255);Delay(255);Delay(255);
     
253.         Delay(255);Delay(255);Delay(255);Delay(255);
     
254. 
     
255.         //读8K
     
256.         for(page=0;page<=0x7F;page++)
     
257.         {//
     
258.                 for(cyc=0;cyc<8;cyc++)
     
259.                 {
     
260.                         addr=0;
     
261.                         for(;addr<4;addr++)
     
262.                         {
     
263.                                 Read_8F08(page,cyc*4+addr);       
     
264.                         }
     
265.                         addr--;
     
266.                         Stop_R8F08();
     
267.                         Delay(255);
     
268.                 }
     
269.                 Delay(255);
     
270.         }
     
271.         Delay(255);
     
272.        
     
273. 
     
274. }
     
275. 
     
276. //=============主函数，无返回值与输入值
     
277. void main()
     
278. {//主函数
     
279.         //OutBuf[0]=0x00;
     
280.         //OutBuf[1]=0xFF;
     
281.         Test();
     
282.         RESET=1;
     
283.         SCLK=1;
     
284.         MOSI=1;
     
285.         /*SCLK=0;
     
286.         MOSI=0;
     
287.         MISO=1;
     
288.         //Delay(255);
     
289.         RESET=0;
     
290.         Delay(255);
     
291.         OutBuf[0]=0xE0;
     
292.         OutBuf[1]=0x5A;
     
293.         OutBuf[2]=0xA5;
     
294.         OutBuf[3]=0xAA;
     
295.         OutBuf[4]=0x00;
     
296.         SendSPI(5);
     
297.         RESET=1;
     
298.         SCLK=1;
     
299.         MOSI=1;*/
     
300.         /*OutBuf[0]=0xE5;
     
301.         OutBuf[1]=0x53;
     
302.         OutBuf[2]=0x35;
     
303.         OutBuf[3]=0x5E;
     
304.         OutBuf[4]=0x00;*/
     
305.         while(1)
     
306.         {
     
307.                 //SendSPI(5);
     
308.                 //Delay(100);
     
309.         }
     
310. }
     

复制代码

xwkm

LGT的SPI口不同于AT89S52的。在复位拉下前SCLK必须拉低，否则会被认为是脉冲上升沿导致数据错位。(谢谢bbsniua的提醒)
这个错误折腾了我整整一个下午。
这个数据包比较简单和规律。每5个BYTE一个帧。前面第一BYTE位命令。第二为地址。第三为页。第四第五是数据。注意第四第五这个WORD值其实是用Middle-Endian表示的INT值。
那么实际上MCU返回的0x55AA就是0xAA55。一样的。
至于如果熔丝加锁以后的解锁办法也简单。初始化后，单单执行earse即可。
判断加了密的芯片，看返回值，如果是0xBD即可证明是加密的。如果在清除状态时发现0xBD的返回可以直接PASS掉芯片不用继续读。因为继续读还是0xBD。
我刚开始的时候是以为在E5 53 35 5E以后直接发送擦除命令即可实现擦除的。没有想到返回值全是F，根本没有成功。
后来发现需要发送这几个命令，可能是清除状态的命令：
B8 3F 07 00 00/BC 3F 07 00 00/A0 00 00 00 00
接着就是擦除命令了。在程序中有。
然后写入的话，使用0x90，0x98这个命令。连续写4次（8BYTES）要停下来，接着重复四次，然后换页继续写。一共是0x80个页，一个页是0x20个WORD，也就是64B，即8K的闪存。
至于EEPROM的话就很简单了。在起始的0x10个页中，其实地址范围从0x00~0x2F，0x00~0x1F给整个用户的flash用。至于0x20~0x2F这个地址是给EEPROM的。

xwkm

至于读命令，就是命令字段为0xB8和0xBC。记住一定要执行两次。
第一次的结果是错误的。有可能是设置内部寄存器的指令，第二条才是真正读。
然后读出的2bytes还是middle-endian的。需要swap。并且每读8bytes(4次)要用0xA0命令停一下，然后继续往后读。
可以在读AP的时候顺带把EEP也读出来。

xwkm

在使用Makefile的时候，LDFLAGS一定要设置堆栈。否则可能出现爆掉的状况。
并且把mcu类型设置为atmega164p。这样gcc才不会报错
LDFLAGS = -Wl,--defsym=__stack=0x8002ff #LGT设置堆栈2FF
MACHINE= atmega164p

xwkm

至少对于LGT8F08A，如果能够长期供货保持如此低的价格的话。入门的门槛是很低的。
只要一块能写入程序的无论什么单片机，甚至有DTR和RTS的串口/EPP并口，就可以用来编程LGT。
找一块洞洞板废料，飞一点线就可以在面包板上做实验了。还是比较方便的。
因为这个最小系统只需要一个单片机和一个电容（甚至也可以不要）就可以了。
不过我强烈建议官方别在新的LGT上去掉ISP功能。第一会导致批量写入程序的麻烦。
第二就是，SWD协议远远比SPI复杂的多。一般的单片机模拟会有一些问题。
这样就会显著的提升入门的门槛。我认为这不是好事情。
另外就是LGT的IO口可以 直接和有弱上拉的5V IO连接，无需电平转换。

ttoto

lz是高中生呢，好厉害了。

logicgreen

值得肯定的，很有潜力的牛人！

xwkm

FUSE->OSCCAL 已经找出：
读出FUSE的命令是：
B8 3C 07 00 00 BC 3C 07 00 00
返回的第二个字节即为OSCCAL值！

xwkm

熔丝使能应该是在楼上第一个字节的低四位。

chengzepeng

1.         Delay(255);Delay(255);Delay(255);Delay(255);
   
2.         Delay(255);Delay(255);Delay(255);Delay(255);
   
3.         Delay(255);Delay(255);Delay(255);Delay(255);
   
4.         Delay(255);Delay(255);Delay(255);Delay(255);
   
5.         Delay(255);Delay(255);Delay(255);Delay(255);

复制代码

还不如弄多个delay_ms()函数算了！

xwkm

chengzepeng 发表于 2012-9-16 13:48
还不如弄多个delay_ms()函数算了！

这个仅仅是测试代码

goodcode

C6 F0 72 A6 0C 55 AA 55        
C6 11000110 OSCCAL – RC 精调控制寄存器
7:保留
6:RPEST R/W 只在 14 脚和 8 脚封装时有效 当设置 PRESETN位为“1”时，复用复位功能的引脚使能复位功能。 当设置 PRESETN位为“0”时，复用复位功能的引脚禁止复位功能。(ISP软件-外部复位使能位)

5:0 RCCAL[5:0] 16MHz RC 精调控制位 (ISP软件-RC时钟校准配置)
55 AA 55
F0 熔丝位 (ISP软件-ISP/LOCK 使能位, 熔丝配置使能位)
-FF 11111111 默认 ISP/LOCK 使能位 解锁 熔丝配置使能位 禁用
-F0 11110000 熔丝配置使能位 启用
72 A6 0C 55 GUID 十六进制0x550CA672
AA 55 未使用

goodcode

要是5v弱上拉能兼容就可以试试手里的1602了

vows

强大的代码，大家原来都睡那么晚

ybx520

顶         

halloocc

lz是高中生? 功力不错了。我高中的时候只能玩z80

xwkm

goodcode 发表于 2012-9-16 19:43
要是5v弱上拉能兼容就可以试试手里的1602了

我试过直接接12232和1602，暂时没问题。
反正我现在直接用STC的上拉链接一点事都木有。

liujian6f

佩服  佩服  牛人