标题: 8051F340单片机MODBUS源程序 [打印本页]

---

作者: ADETEGA    时间: 2018-3-9 16:05
标题: 8051F340单片机MODBUS源程序
8051F340MODBUS程序，学习学习

单片机源程序如下:

1. #include"C8051F120.h"
   
2. #include"VVVF.h"
   
3. #include"UART.h"
   
4. #include"DataProcess.h"
   
5. sbit S_SL=P5^5;
   
6. /*------------------------------------------------------------------------------------
   
7. 函数名:Send485Data()
   
8. 函数功能:发送一个字节485数据
   
9. 参数:uchar dat;
   
10. 返回:void
    
11. -------------------------------------------------------------------------------------*/
    
12. void Send485Data(uchar xdata dat){
    
13.     uchar  xdata old_SFRPAGE;
    
14.     old_SFRPAGE=SFRPAGE;
    
15.     SFRPAGE   = CONFIG_PAGE;
    
16.         UART0_Init(9600);
    
17.     S_SL=1;/////关闭485发送 防止在不需要的时候数据写
    
18.         UART0SendOneByte(dat);
    
19.   //P4&=0xEF;/////关闭485发送 防止在不需要的时候数据写,???????????影响串口中断
    
20.     UART0_End();
    
21.         S_SL=0;
    
22.     SFRPAGE=old_SFRPAGE;
    
23. }
    
24. void SendVVVFCommand(uchar xdata comm, uint xdata StartAddr,uint xdata para){
    
25.    uchar xdata commstr[8],i;
    
26.    uint xdata CRC;
    
27.    commstr[0]=0x01;//命令机号
    
28.    commstr[1]=comm;//命令
    
29.    commstr[2]=StartAddr/256;//起始地址高在前地在后
    
30.    commstr[3]=StartAddr%256;
    
31.    commstr[4]=para/256;
    
32.    commstr[5]=para%256;//参数
    
33.    CRC=VVVF_CRC_CHK(commstr,6);
    
34.    commstr[6]=CRC%256;
    
35.    commstr[7]=CRC/256;
    
36.    for(i=0;i<8;i++){
    
37.      Send485Data(commstr[i]);
    
38.    }
    
39. }   
    
40. /*------------------------------------------------------------------------------------
    
41. 函数名:MotorRun()
    
42. 函数功能:启动电机 即启动变频器
    
43. 参数: void
    
44. 返回:void
    
45. -------------------------------------------------------------------------------------*/
    
46. void MotorRun(){
    
47.     SendVVVFCommand(0x06,0x2000,0x0002);
    
48. }
    
49. /*------------------------------------------------------------------------------------
    
50. 函数名:MotorStop()
    
51. 函数功能:停止电机 即停止变频器
    
52. 参数: void
    
53. 返回:void
    
54. -------------------------------------------------------------------------------------*/
    
55. void MotorStop(){
    
56.     SendVVVFCommand(0x06,0x2000,0x0001);
    
57. }
    
58. /*------------------------------------------------------------------------------------
    
59. 函数名:MotorFWD()
    
60. 函数功能:电机正转命令
    
61. 参数: void
    
62. 返回:void
    
63. -------------------------------------------------------------------------------------*/
    
64. void MotorFWD(){
    
65.     SendVVVFCommand(0x06,0x2000,0x0010);
    
66. }
    
67. /*------------------------------------------------------------------------------------
    
68. 函数名:MotorREV()
    
69. 函数功能:电机反转命令
    
70. 参数: void
    
71. 返回:void
    
72. -------------------------------------------------------------------------------------*/
    
73. void MotorREV(){
    
74.     SendVVVFCommand(0x06,0x2000,0x0020);
    
75. }
    
76. /*------------------------------------------------------------------------------------
    
77. 函数名:SetFrequnce()
    
78. 函数功能:设置频率
    
79. 参数: float xdata freq
    
80. 返回:void
    
81. -------------------------------------------------------------------------------------*/
    
82. void SetFrequence(float xdata  freq){
    
83.     SendVVVFCommand(0x06,0x2001,freq*100);
    
84. }
    
85. 
    
86. // MotorStop();
    
87. /*SetFrequence(40);
    
88.    MotorFWD();
    
89.    MotorREV();
    
90.    SetFrequence(60);
    
91.     SetFrequence(50);
    
92.     SetFrequence(45);
    
93.          SetFrequence(61);
    
94.           SetFrequence(65);
    
95.            SetFrequence(66);
    
96.     SetFrequence(150);
    
97.          SetFrequence(180);*/
    
98.   // SendVVVFCommand(0x06,0x2001,5000);
    
99.    //SendVVVFCommand(0x06,0x2000,0x0002);
    
100.    //SendVVVFCommand(0x06,0x2000,0x0001);
     
101.    //Num=UART0ReceiveOneByte();
     

复制代码

1. //modbus通信协议实现
   
2. //
   
3. 
   
4. #include <c8051f340.h>            
   
5. #include <intrins.h>
   
6. //-----------------------------------------------------------------------------
   
7. // Global CONSTANTS
   
8. //-----------------------------------------------------------------------------
   
9. #define BaudRate       19200//9600,14400,19200,38400,56000可选        
   
10. #define SYSCLK         12000000   
    
11. //#define BAUDRATE     9600         
    
12. //#define SYSCLK       11059200     
    
13. sbit GREEN = P2^2;
    
14. sbit RED   = P2^1;
    
15. sbit PF    = P2^0;
    
16. //-----------------------------------------------------------------------------
    
17. // Function PROTOTYPES
    
18. //-----------------------------------------------------------------------------
    
19. 
    
20. #define u16 unsigned int
    
21. #define u8 unsigned char
    
22. #define   MAXNByte  15   //最大字节数
    
23. //#define  time0      30000
    
24. #define  MAXREG     100   //最大寄存器数量
    
25. 
    
26. //void SYSCLK_Init (void);
    
27. void PORT_Init (void);   //IO口初始化
    
28. void UART0_Init (void);   //uart0初始化
    
29. 
    
30. void readRegisters(void) ;//读寄存器,功能码03
    
31. void beginSend(void) ;    //发送子程序
    
32. void presetMultipleRegisters(void);//设置多个寄存器,功能码16
    
33. void FLASH_ByteWrite(u16 addr, u8 byte);//flash写
    
34. void FLASH_PageErase (u16 addr);        //flash页擦写
    
35. //void Receive_timeout(void);             //超时子程序
    
36. u16 crc_chk(u8 *dat,u8 length);         //CRC校验
    
37. u8 FLASH_ByteRead (u16 addr);           //flash读
    
38. //void presetSingleRegisters(void);       //设置单个寄存器,功能码06
    
39. void send_err(u8 err,u8 err_code);       //发送错误
    
40. void Timer0_Init(void);                  //定时器0初始化
    
41. void PCA_Init();
    
42. u16 flag;
    
43. u8 temp;
    
44. u8 count_receiveNByte;//接收字节数
    
45. u8 mod_buf[20];       //modubs 数据接收缓冲区
    
46. u8 sendBuf[20];       //发送缓冲区
    
47. u8 sendCount;         //发送字节数
    
48. u8 localAddr = 3;     //单片机控制板的地址
    
49. //u16 Receivetimeout;    //定时初值
    
50. //bit ReceiveBit;   
    
51. 
    
52. //unsigned int  code  baud_code[8] = {};
    
53. /*?????*/
    
54. /*void delay(unsigned int m)
    
55. {
    
56. unsigned int n;
    
57. n=0;
    
58. while(n < m)
    
59. {n++;}
    
60. return;
    
61. }  */
    
62. //-----------------------------------------------------------------------------
    
63. // MAIN Routine
    
64. //-----------------------------------------------------------------------------
    
65. 
    
66. void main(void)
    
67. {
    
68.    u16 dat;
    
69.    u16 tempData;
    
70.    u16 crcData;
    
71.    PCA0MD    &= ~0x40;                    
    
72.    OSCICN    |= 0x03;
    
73. 
    
74.    //SYSCLK_Init ();                     
    
75.     PORT_Init ();                       
    
76.     UART0_Init ();
    
77.     PCA_Init();                    
    
78. //         Timer0_Init();
    
79.     EA=1;
    
80.     ES0=1;
    
81.         PS0=1;
    
82.         GREEN=1;     
    
83.     RED=0;
    
84. while(1){
    
85.   if (mod_buf[0]==localAddr)
    
86.   {
    
87.      if(count_receiveNByte>4)
    
88.         {
    
89. 
    
90. 
    
91.     switch(mod_buf[1])
    
92.         {
    
93.        case 0x03:
    
94.                             if(count_receiveNByte>=8)
    
95.                                            {
    
96.                                           crcData = crc_chk(mod_buf,6);  //CRC校验
    
97.                           dat=mod_buf[7];
    
98.                           if(crcData==mod_buf[6]+(dat<<8)) //CRC校验结果比较
    
99.                         
    
100.                               readRegisters();         // 如果检验正确，那么就回应数据
     
101.                                                           count_receiveNByte=0;     //接受数据指针归零   
     
102.                                                  
     
103.                          }
     
104.                     break;
     
105.                     
     
106.                  
     
107. /*            case 0x06:
     
108.                if(count_receiveNByte>=8)
     
109.                                        {
     
110.                                      crcData = crc_chk(mod_buf,6);  //CRC校验
     
111.                                          dat=mod_buf[7];
     
112.                    if(crcData==mod_buf[6]+(dat<<8)) //CRC校验结果比较
     
113.                      
     
114.                             presetSingleRegisters();
     
115.                     count_receiveNByte=0;     //接受数据指针归零  
     
116.                                }
     
117.                    break;*/
     
118.             case 0x10:
     
119.                            dat=mod_buf[4];
     
120.                    tempData = (dat<<8) + mod_buf[5];
     
121.                    tempData = tempData * 2; //数据个数
     
122.                    tempData += 9;
     
123.                 if(count_receiveNByte >= tempData)
     
124.                  {
     
125.                   
     
126.                      crcData = crc_chk(mod_buf,tempData-2);
     
127.                      dat=mod_buf[tempData-1];
     
128.                     if(crcData == (dat<<8)+ mod_buf[tempData-2])
     
129.                      
     
130.                                 presetMultipleRegisters();
     
131.                                                 count_receiveNByte=0;     //接受数据指针归零   
     
132.                                        
     
133.                                  }
     
134.                                   break;
     
135.                  default:
     
136.                   break;
     
137.          }
     
138.                                
     
139. 
     
140.    }
     
141.    
     
142.          
     
143.   }
     
144.   else
     
145.     count_receiveNByte=0;     //接受数据指针归零
     
146.   _nop_();
     
147. //    Receive_timeout();
     
148.    PCA0CPH4 = 0x00;
     
149. }
     
150. }
     
151. 
     
152. //-----------------------------------------------------------------------------
     
153. // SYSCLK_Init
     
154. //-----------------------------------------------------------------------------
     
155. //
     
156. // This routine initializes the system clock to use an 22.1184MHz crystal
     
157. // as its clock source.
     
158. //
     
159. //void SYSCLK_Init (void)
     
160. //{
     
161. //   int i;                              
     
162. 
     
163. //   OSCXCN = 0x67;                     
     
164. //  for (i=0; i < 256; i++) ;         
     
165. 
     
166. //   while (!(OSCXCN & 0x80)) ;         
     
167. 
     
168. //   OSCICN = 0x88;                     
     
169. //}
     
170. 
     
171. //-----------------------------------------------------------------------------
     
172. // PORT_Init
     
173. //-----------------------------------------------------------------------------
     
174. //
     
175. // Configure the Crossbar and GPIO ports
     
176. //
     
177. 
     
178. void PCA_Init()
     
179. {
     
180.     PCA0CN     =  0x40;                // PCA counter enable
     
181.     PCA0MD    &= ~0x40 ;               // Watchdog timer disabled-clearing bit 6
     
182.     PCA0MD    &=  0xF1;                // timebase selected - System clock / 12
     
183.     PCA0CPL4   =  0xFF;                // Offset value
     
184.     PCA0MD  |= 0x40;
     
185.     PCA0L    = 0x00;                          // Set lower byte of PCA counter to 0  
     
186.     PCA0H    = 0x00;
     
187. }
     
188. 
     
189. void PORT_Init (void)
     
190. {
     
191.    XBR0    = 0x01;                      //UART TX0, RX0连到端口引脚P0.4和P0.5
     
192.    XBR1    = 0x40;
     
193.    XBR2    = 0x00;                     //UART1的I/O不连到端口引?
     
194.    P0MDOUT |= 0x01;                    //TX0输出为推挽方式
     
195.    P2MDOUT |= 0x3f;                  
     
196.    P1MDOUT |= 0xff;
     
197. //   P0SKIP  |= 0xc0;
     
198. }
     
199. 
     
200. //-----------------------------------------------------------------------------
     
201. // UART0_Init
     
202. //-----------------------------------------------------------------------------
     
203. //
     
204. // Configure the UART0 using Timer1, for <baudrate> and 8-N-1.
     
205. //
     
206. void UART0_Init (void)
     
207. {
     
208.     SCON0   = 0x50;                    
     
209.     TMOD    = 0x20;                    
     
210.         if(BaudRate > 38400)                 
     
211.         {
     
212.                 CKCON  = 0x08;                      //定时器使用系统时钟
     
213.                 TH1    = 256-SYSCLK/2/BaudRate;
     
214.         }
     
215.         if(BaudRate <= 38400)
     
216.         {
     
217.                 CKCON  = 0x01;                      //定时器时钟用系统时钟的4分频
     
218.                 TH1    = 256-SYSCLK/4/2/BaudRate;
     
219.         }
     
220.    TL1=TH1;
     
221.    TR1    = 1;                        
     
222.    CKCON |= 0x01;                      //定时器时钟用系统时钟的4分频
     
223.    PF=0;
     
224. }
     
225. 
     
226. /*void Timer0_Init(void)
     
227. {
     
228. TMOD |= 0x01;        // 定时器0: 方式1,16位定时器
     
229. TF0=0;        
     
230. TR0=1;// TR0
     
231. CKCON |= 0x10;        //
     
232. TH0 = 0xf1; //256 -((60*SYSCLK/1000/12)/256);
     
233. TL0 = 0xc2;//256 -((60*SYSCLK/1000/12)%256);
     
234. ET0=1;
     
235. }
     
236. 
     
237. void timer0() interrupt 1 using 2 //定时器中断
     
238. {   
     
239.     TF0=0;
     
240.     TR0=0;
     
241.     TH0=0xf1;    //3.646ms interrupt
     
242.     TL0=0xc2;
     
243.     flag++;
     
244.         if(flag==15)
     
245.          {
     
246.            flag=0;
     
247.        if(count_receiveNByte<=2)    //超时后，若接收缓冲区有数则判断为收到一帧
     
248.        {
     
249.               count_receiveNByte=0;     //接受数据指针归零   ;
     
250.        }
     
251.           }
     
252.         TR0=1;
     
253. }
     
254. /***********************************************************
     
255. CRC校验
     
256. ***************************************************************/
     
257. u16 crc_chk(u8 *pData,u8 nLen)
     
258. {
     
259. u16 temp=0xffff,temp1,i,j;
     
260. for(i=0;i<nLen;i++)
     
261.     {
     
262.     temp^=*(pData+i);
     
263.         for(j=0;j<8;j++)
     
264.                 {
     
265.                 temp1=temp;
     
266.                 temp>>=1;
     
267.                 if(temp1&0x0001)
     
268.                         temp^=0xa001;
     
269.         }
     
270.     }
     
271. return(temp);
     
272. }
     
273. 
     
274. /*功能码03读*/
     
275. void readRegisters(void)
     
276. {
     
277.    u16 addr;
     
278.    u16 tempAddr;
     
279. // u16 result;
     
280.    u16 crcData;
     
281.    u8 readCount;
     
282.    u8 byteCount;
     
283. 
     
284. // u8  finsh; //
     
285.    u8 i;
     
286.    u16 tempData = 0;
     
287.    tempData=mod_buf[2];
     
288.    addr = (tempData<<8) + mod_buf[3];
     
289.    tempAddr = addr ;//& 0xfff;
     
290.    //addr = mod_buf[3];
     
291.    //tempAddr = addr;
     
292. 
     
293. //readCount = (receBuf[4]<<8) + receBuf[5];
     
294.    readCount  = mod_buf[5];
     
295.    if(readCount<MAXREG)
     
296.    {
     
297.        byteCount = readCount* 2 ;//;
     
298. 
     
299.       for(i=0;i<byteCount;i++,tempAddr++)
     
300.       {
     
301.           tempData=FLASH_ByteRead(tempAddr);
     
302.           //getRegisterVal(tempAddr,&tempData);   
     
303.           sendBuf[i+3] = tempData;// & 0xff;
     
304.   
     
305.        }
     
306. 
     
307.        sendBuf[0] = localAddr;
     
308.        sendBuf[1] = 3;
     
309.        sendBuf[2] = byteCount;
     
310.        byteCount += 3;
     
311.        crcData = crc_chk(sendBuf,byteCount);
     
312.        sendBuf[byteCount] = crcData & 0xff;
     
313.        byteCount++;
     
314.        sendBuf[byteCount] =  crcData >> 8;
     
315. 
     
316.        sendCount = byteCount + 1;
     
317.        beginSend();
     
318.    }
     
319.    else
     
320.         {
     
321. 
     
322.             send_err(0x83,0x03);
     
323.     }
     
324. }//void readRegisters(void)
     
325. 
     
326. /*****************************************************************
     
327. 功能码6 设置单个寄存器
     
328. ******************************************************************
     
329. void presetSingleRegisters(void)
     
330. {
     
331. u16 addr;
     
332. u16 tempAddr;
     
333. 
     
334. 
     
335. u16 crcData;
     
336. u16 tempData;
     
337. // uint8  finsh; //为1时完成 为0时出错
     
338. 
     
339. tempData=mod_buf[2];
     
340. addr = (tempData<<8) + mod_buf[3];
     
341.   tempAddr = addr;// & 0xfff;
     
342.   //addr = mod_buf[3];
     
343.   //tempAddr = addr & 0xff;
     
344. 
     
345.   //setCount = (receBuf[4]<<8) + receBuf[5];
     
346.   //setCount = mod_buf[5];
     
347.   //byteCount = mod_buf[6];
     
348. 
     
349.      FLASH_PageErase (tempAddr);
     
350. 
     
351. //    tempData = (modbuf[i*2+7]<<8) + modbuf[i*2+8];
     
352.       tempData=mod_buf[4];
     
353. //    setRegisterVal(tempAddr,tempData);
     
354.       FLASH_ByteWrite (tempAddr, tempData);
     
355.           sendBuf[4] = tempData ;
     
356.           tempData=mod_buf[5];
     
357.           FLASH_ByteWrite (tempAddr+1, tempData);         
     
358.       sendBuf[5] = tempData;
     
359. 
     
360. 
     
361. sendBuf[0] = localAddr;
     
362. sendBuf[1] = 6;
     
363. sendBuf[2] = addr >> 8;
     
364. sendBuf[3] = addr & 0xff;
     
365. crcData = crc_chk(sendBuf,6);
     
366. sendBuf[6] = crcData & 0xff;
     
367. sendBuf[7] = crcData >> 8;
     
368. sendCount = 8;
     
369. beginSend();
     
370. }
     
371. 
     
372. /****************************************************************
     
373. 功能码16，设置多个功能寄存器
     
374. ******************************************************************/
     
375. void presetMultipleRegisters(void)
     
376. {
     
377. 
     
378. u16 addr;
     
379. u16 tempAddr;
     
380. u8 byteCount;
     
381. u8 setCount;
     
382. u16 crcData;
     
383. u16 tempData;
     
384. // uint8  finsh; //为1时完成 为0时出错
     
385. u8 i;
     
386. 
     
387. //addr = mod_buf[3];
     
388. tempData=mod_buf[2];
     
389. addr = (tempData<<8) + mod_buf[3];
     
390. tempAddr = addr;// & 0xfff;
     
391. 
     
392. //tempAddr = addr & 0xff;
     
393. 
     
394. //setCount = (receBuf[4]<<8) + receBuf[5];
     
395. setCount = mod_buf[5];
     
396. if(setCount<=0x78)
     
397. {
     
398.   byteCount = mod_buf[6];
     
399. 
     
400. 
     
401. sendBuf[0] = localAddr;
     
402. sendBuf[1] = 16;
     
403. sendBuf[2] = addr >> 8;
     
404. sendBuf[3] = addr & 0xff;
     
405. sendBuf[4] = setCount >> 8;
     
406. sendBuf[5] = setCount & 0xff;
     
407. crcData = crc_chk(sendBuf,6);
     
408. sendBuf[6] = crcData & 0xff;
     
409. sendBuf[7] = crcData >> 8;
     
410. sendCount = 8;
     
411. beginSend();
     
412. 
     
413.     FLASH_PageErase (0x7c00);
     
414. 
     
415.    for(i=0;i<byteCount;i++,tempAddr++)
     
416.    {
     
417. //    tempData = (modbuf[i*2+7]<<8) + modbuf[i*2+8];
     
418.       tempData=mod_buf[7+i];
     
419. //    setRegisterVal(tempAddr,tempData);
     
420. 
     
421.       FLASH_ByteWrite (tempAddr, tempData);
     
422.    }
     
423. 
     
424. }
     
425. else//寄存器数量>120
     
426.    {
     
427. 
     
428.      send_err(0x90,0x03);
     
429. 
     
430.    }
     
431. 
     
432. }//void presetMultipleRegisters(void)
     
433. 
     
434. 
     
435. 
     
436. 
     
437. /*UART0中断处理*/
     
438. void UART0_ISR (void) interrupt 4
     
439. {
     
440. ES0=0;
     
441. if(!TI0)              
     
442.    {
     
443. //    Receivetimeout=time0;
     
444.     RI0 = 0;  
     
445.     mod_buf[count_receiveNByte] = SBUF0; //获取数据
     
446.    count_receiveNByte++;       //接收字节数目
     
447. //   Receivetimeout=350;  
     
448.   if(count_receiveNByte >= MAXNByte)   //如果接收满
     
449.    count_receiveNByte = 0;     //接受满 归0  
     
450.    
     
451.    }
     
452.   TI0 = 0;   
     
453.   ES0=1;
     
454. }
     
455. //发送子程序
     
456. void beginSend(void)
     
457. {        u8 i;
     
458.         ES0=0;
     
459.         GREEN=0;
     
460.                 RED=1;
     
461.                 PF=1;          //485允许发送
     
462.          for(i=0;i<sendCount;i++)
     
463.        {
     
464.         SBUF0 = sendBuf[i];
     
465.         while(TI0==0);
     
466.         TI0=0;
     
467.        }
     
468.            PF=0;           //485允许接收
     
469.            GREEN=1;
     
470.            RED=0;
     
471.            ES0=1;
     
472. }
     
473. 
     
474. void send_err(u8 err,u8 err_code)//发送错误
     
475. {
     
476.   u16 crc_tmp;
     
477.        
     
478.   sendBuf[0]=localAddr;
     
479.   sendBuf[1]=err;
     
480.   sendBuf[2]=err_code;
     
481.   crc_tmp=crc_chk(mod_buf,3);
     
482.   sendBuf[3]=crc_tmp;
     
483.   sendBuf[4]=crc_tmp>>8;
     
484.   sendCount=5;
     
485.   beginSend();       
     
486.   
     
487. }
     
488. /*****************************************************
     
489. 接收超时判断
     
490. 调用条件：
     
491. ((Receivetime_flag=1)&&(count_receiveNByte>0))  1ms定时时间到
     
492. 并且 有接收到的字符，调用此模块，判定是否接收超时
     
493. *****************************************************
     
494. void Receive_timeout(void)
     
495. {
     
496. Receivetimeout--;
     
497. if((Receivetimeout==0)&&(count_receiveNByte>0)) //说明接收超时
     
498.   {
     
499.    count_receiveNByte=0;     //接受数据指针归零
     
500.    SCON0|=0x10;       //允许UART0接收，REN0=1;
     
501.   }
     
502. }*/
     
503. void FLASH_PageErase (u16 addr)
     
504. {
     
505.    bit EA_SAVE = EA;                   // Preserve EA
     
506.    char xdata * data pwrite;           // FLASH write pointer
     
507. 
     
508.    EA = 0;                             // Disable interrupts
     
509.    // change clock speed to slow, then restore later
     
510. 
     
511.    VDM0CN = 0x80;                      // Enable VDD monitor
     
512.        
     
513.    RSTSRC |= 0x02;                      // enable VDD monitor as a reset source
     
514. 
     
515.   
     
516.    FLKEY  = 0xA5;                      // Key Sequence 1
     
517.    FLKEY  = 0xF1;                      // Key Sequence 2
     
518.    PSCTL |= 0x03;                      // PSWE = 1; PSEE = 1
     
519. 
     
520. 
     
521.    VDM0CN = 0x80;                      // Enable VDD monitor
     
522. 
     
523.    RSTSRC |= 0x02;                      // Enable VDD monitor as a reset source
     
524. 
     
525.    pwrite = (char xdata *) addr;
     
526. 
     
527.    VDM0CN = 0x80;                      // Enable VDD monitor
     
528.        
     
529.    *pwrite = 0;                        // Initiate page erase
     
530. 
     
531.    PSCTL &= ~0x03;                     // PSWE = 0; PSEE = 0
     
532. 
     
533.    EA = EA_SAVE;                       // Restore interrupts
     
534. }
     
535. /********************************************************************
     
536. 读寄存器值
     
537. ********************************************************************/
     
538. u8 FLASH_ByteRead (u16 addr)
     
539. {
     
540.    bit EA_SAVE = EA;                   // Preserve EA
     
541.    char code * data pread;             // FLASH read pointer
     
542.    unsigned char byte;
     
543. 
     
544.    EA = 0;                             // Disable interrupts
     
545. 
     
546.    pread = (char code *) addr;
     
547. 
     
548.    byte = *pread;                      // Read the byte
     
549. 
     
550.    EA = EA_SAVE;                       // Restore interrupts
     
551. 
     
552.    return byte;
     
553. }
     
554. /************************************************************
     
555. Flash写
     
556. ************************************************************/
     
557. void FLASH_ByteWrite (u16 addr, u8 byte)
     
558. {
     
559.    bit EA_SAVE = EA;                   // Preserve EA
     
560.    char xdata * data pwrite;           // FLASH write pointer
     
561. 
     
562.    EA = 0;                             // Disable interrupts
     
563. 
     
564.    // change clock speed to slow, then restore later
     
565. 
     
566.    VDM0CN = 0x80;                      // Enable VDD monitor
     
567. 
     
568.    RSTSRC |= 0x02;                      // Enable VDD monitor as a reset source
     
569. 
     
570.    pwrite = (char xdata *) addr;
     
571. 
     
572.    PFE0CN &= 0XFE;                //设定单字节写入FLASH方式
     
573. 
     
574.    PSCTL |= 0x01;                      // PSWE = 1
     
575.    FLKEY  = 0xA5;                      // Key Sequence 1
     
576.    FLKEY  = 0xF1;                      // Key Sequence 2
     
577. 
     
578.    VDM0CN = 0x80;                      // Enable VDD monitor
     
579. 
     
580. 
     
581.    RSTSRC |= 0x02;                      // Enable VDD monitor as a reset source
     
582. 
     
583.    VDM0CN = 0x80;                      // Enable VDD monitor
     
584. 
     
585.    *pwrite = byte;                     // Write the byte
     
586. 
     
587.    PSCTL &= ~0x01;                     // PSWE = 0
     
588. 
     
589.    EA = EA_SAVE;                       // Restore interrupts
     
590. }
     
591. 
     

复制代码

所有资料51hei提供下载:
340.zip (51.69 KB, 下载次数: 55)

2018-3-9 16:03 上传

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

---

作者: wadz3652002    时间: 2018-7-12 01:14
正好需要。。。。。。。。。。。。。。。。。。。。。。。。。

---

作者: 竹子开花    时间: 2018-8-12 10:31
需要。。。。。。。。。。。。。。。。。。。。。。。

---

作者: WFX777888    时间: 2018-8-12 12:07
谢谢分享资料

---

作者: yanfeng082    时间: 2020-10-29 14:42
请问这个怎么能移植到c51单片机上用来控制变频器

---

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

Powered by Discuz! X3.1