经过小弟的一个周末的努力，终于发现STM8S不能块编程的原因了。首先STM8S的块编程，需要把程序放在RAM中运行。对于像我这样没学过汇编的，也不了解编译器原理的，只知道用C语言写写程序的朋友。有点摸不着头脑。那么如何让程序在RAM中运行呢？
我们看下STM8S的库函数数就知道了。下面是库函数的代码。

IN_RAM(void FLASH_EraseBlock(uint16_t BlockNum, FLASH_MemType_TypeDef FLASH_MemType));

我刚开始就被这个函数定义给骗了。以为加了IN_RAM( )，就可以在RAM中运行了。我们看下 IN_RAM() 的定义
  #define IN_RAM(a)  a
在默认情况下，它什么都没干。仔细一下，在默认情况下，是不库函数把在RAM中运行程序的功能给屏蔽了。

/* Uncomment the line below to enable the FLASH functions execution from RAM */
#if !defined (RAM_EXECUTION)
/*#define RAM_EXECUTION  (1) */
#endif /* RAM_EXECUTION */


取消掉这个注释就可以了。把它变成

/* Uncomment the line below to enable the FLASH functions execution from RAM */
#if !defined (RAM_EXECUTION)
   #define RAM_EXECUTION  (1)
#endif /* RAM_EXECUTION */


这样IN_RAM（）的定义就变成了
  #define IN_RAM(a)   __ramfunc  a

再去调试程序。就好了。

自己写程序其实就是在函数前面加下  __ramfunc  


下面是我测试成功的程序


uint8_t  block_buff[128];

__ramfunc  void  WriteBlock(void)
{
  uint8_t i;

    FLASH_Unlock(FLASH_MEMTYPE_DATA);
    FLASH->CR2 |= FLASH_CR2_PRG;
    FLASH->NCR2 &= (uint8_t)(~FLASH_NCR2_NPRG);

  for(i=0; i<128; i++)
  {
    *((PointerAttr uint8_t*) (MemoryAddressCast)0x4000 + i) = block_buff[i];
  }

   FLASH_Lock(FLASH_MEMTYPE_DATA);
}


祝还不会块编程的朋友们好运！！！！！




但是看门狗我还不知道原因。在接上STLINK调试的时候，看门狗会死机，但是在程序自己运行时，它就正常了

真不错！学习啦

学习学习

这是因为你在解锁时，是不能设置监控的，你用STLINK调试时，在这里是容易出问题的，一般不作监控。

/* MAIN.C file
*
* Copyright (c) 2002-2005 STMicroelectronics
*/
#include "stm8s.h"
#include <stdio.h>
int _fctcpy(char name);
main()
{
u8 block_buff[128] ={0};
u8 i = 0;
u8 c = 0;
_fctcpy('F');

CLK_DeInit();
  CLK_HSICmd(ENABLE);
CLK_SYSCLKConfig(CLK_PRESCALER_HSIDIV1);

  UART1_DeInit();
  UART1_Init((u32)115200, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO,
UART1_SYNCMODE_CLOCK_DISABLE,UART1_MODE_TXRX_ENABLE);
  UART1_ITConfig(UART1_IT_RXNE_OR, ENABLE);
  UART1_Cmd(ENABLE);
  
GPIO_DeInit(GPIOD);
  GPIO_Init(GPIOD, GPIO_PIN_LNIB, GPIO_MODE_OUT_PP_LOW_FAST);

for(i=0;i<128;i++)
   block_buff=i;

  FLASH_DeInit();
  FLASH_Unlock(FLASH_MEMTYPE_DATA);
  FLASH_SetProgrammingTime(FLASH_PROGRAMTIME_TPROG);
  FLASH_ProgramBlock(0x0001, FLASH_MEMTYPE_DATA, FLASH_PROGRAMMODE_STANDARD, block_buff);
FLASH_EraseBlock(0x0001, FLASH_MEMTYPE_DATA);

c = FLASH_ReadByte(0x40ff);//读出值到变量中
printf("c=%x\r\n",(u16)c);//打印
c = FLASH_ReadByte(0x407f);
printf("c=%x\r\n",(u16)c);
c = FLASH_ReadByte(0x4080);
printf("c=%x\r\n",(u16)c);
c = FLASH_ReadByte(0x4100);
printf("c=%x\r\n",(u16)c);

_asm("rim");
while (1)
  {
  GPIO_WriteHigh(GPIOD, GPIO_PIN_LNIB);
}
}
char putchar (char c)    //串口打印重定向，只要有这个函数，然后包含stdio.h就可以直接调用打印函数了，若有不成功时请把参数前强转为（u16）
{
  if (c == '\n')
  {
    /* put '\r' to hardware here */
    /* Wait transmission is completed : otherwise the first data is not sent */
    while (!(UART1->SR & 0x40));
    UART1->DR = ('\r');
    /* Wait transmission is completed */
    while (!(UART1->SR & 0x40));
}
  /* put c to hardware here */
  /* Wait transmission is completed : otherwise the first data is not sent */
  while (!(UART1->SR & 0x80));
  UART1->DR = (c);
  /* Wait transmission is completed */
  while (!(UART1->SR & 0x80));
  return (c);
}

用Cosmic编译，使用ST库函数，已经调试通过，供大家参考一下。

1. //用Cosmic编译，使用ST库函数，已经调试通过，供大家参考一下。
   
2. /* MAIN.C file
   
3. *
   
4. * Copyright (c) 2002-2005 STMicroelectronics
   
5. */
   
6. #include "stm8s.h"
   
7. #include <stdio.h>
   
8. int _fctcpy(char name);
   
9. main()
   
10. {
    
11. u8 block_buff[128] ={0};
    
12. u8 i = 0;
    
13. u8 c = 0;
    
14. _fctcpy('F');
    
15. 
    
16. CLK_DeInit();
    
17.   CLK_HSICmd(ENABLE);
    
18. CLK_SYSCLKConfig(CLK_PRESCALER_HSIDIV1);
    
19. 
    
20.   UART1_DeInit();
    
21.   UART1_Init((u32)115200, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO,
    
22. UART1_SYNCMODE_CLOCK_DISABLE,UART1_MODE_TXRX_ENABLE);
    
23.   UART1_ITConfig(UART1_IT_RXNE_OR, ENABLE);
    
24.   UART1_Cmd(ENABLE);
    
25.   
    
26. GPIO_DeInit(GPIOD);
    
27.   GPIO_Init(GPIOD, GPIO_PIN_LNIB, GPIO_MODE_OUT_PP_LOW_FAST);
    
28. 
    
29. for(i=0;i<128;i++)
    
30.    block_buff=i;
    
31. 
    
32.   FLASH_DeInit();
    
33.   FLASH_Unlock(FLASH_MEMTYPE_DATA);
    
34.   FLASH_SetProgrammingTime(FLASH_PROGRAMTIME_TPROG);
    
35.   FLASH_ProgramBlock(0x0001, FLASH_MEMTYPE_DATA, FLASH_PROGRAMMODE_STANDARD, block_buff);
    
36. FLASH_EraseBlock(0x0001, FLASH_MEMTYPE_DATA);
    
37. 
    
38. c = FLASH_ReadByte(0x40ff);//读出值到变量中
    
39. printf("c=%x\r\n",(u16)c);//打印
    
40. c = FLASH_ReadByte(0x407f);
    
41. printf("c=%x\r\n",(u16)c);
    
42. c = FLASH_ReadByte(0x4080);
    
43. printf("c=%x\r\n",(u16)c);
    
44. c = FLASH_ReadByte(0x4100);
    
45. printf("c=%x\r\n",(u16)c);
    
46. 
    
47. _asm("rim");
    
48. while (1)
    
49.   {
    
50.   GPIO_WriteHigh(GPIOD, GPIO_PIN_LNIB);
    
51. }
    
52. }
    
53. char putchar (char c)    //串口打印重定向，只要有这个函数，然后包含stdio.h就可以直接调用打印函数了，若有不成功时请把参数前强转为（u16）
    
54. {
    
55.   if (c == '\n')
    
56.   {
    
57.     /* put '\r' to hardware here */
    
58.     /* Wait transmission is completed : otherwise the first data is not sent */
    
59.     while (!(UART1->SR & 0x40));
    
60.     UART1->DR = ('\r');
    
61.     /* Wait transmission is completed */
    
62.     while (!(UART1->SR & 0x40));
    
63. }
    
64.   /* put c to hardware here */
    
65.   /* Wait transmission is completed : otherwise the first data is not sent */
    
66.   while (!(UART1->SR & 0x80));
    
67.   UART1->DR = (c);
    
68.   /* Wait transmission is completed */
    
69.   while (!(UART1->SR & 0x80));
    
70.   return (c);
    
71. }

复制代码

另：两把密钥的顺序不是随便的，解锁eeprom时顺序是0xae,0x56，解锁flash时顺序是0x56,0xae，我见过网上有人说顺序不分的，纠正下，不要误人子弟！顺序出错是了怎么都出不来的，ST英文原文写得很清楚了，有些翻译就是翻译错了，大家注意一下。

再贴上ST公司调用库文件的例子，供参考：

1. /**
   
2.   ******************************************************************************
   
3.   * @file     FLASH/FLASH_DataProgram/main.c
   
4.   * @author   MCD Application Team
   
5.   * @version  V2.2.0
   
6.   * @date     30-September-2014
   
7.   ******************************************************************************
   
8.   * @attention
   
9.   *
   
10.   * <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>
    
11.   *
    
12.   * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
    
13.   * You may not use this file except in compliance with the License.
    
14.   * You may obtain a copy of the License at:
    
15.   *
    
16.   *        http://www.st.com/software_license_agreement_liberty_v2
    
17.   *
    
18.   * Unless required by applicable law or agreed to in writing, software
    
19.   * distributed under the License is distributed on an "AS IS" BASIS,
    
20.   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
21.   * See the License for the specific language governing permissions and
    
22.   * limitations under the License.
    
23.   *
    
24.   ******************************************************************************
    
25.   */
    
26. 
    
27. /* Includes ------------------------------------------------------------------*/
    
28. #include "stm8s.h"
    
29. #include "stm8s_eval.h"
    
30. 
    
31. /**
    
32.   * @addtogroup FLASH_DataProgram
    
33.   * @{
    
34.   */
    
35. 
    
36. /* Private typedef -----------------------------------------------------------*/
    
37. typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus;
    
38. /* Private define ------------------------------------------------------------*/
    
39. #define BLOCK_OPERATION    0    /* block 0 in data eeprom memory: address is 0x4000 */
    
40. /* Private macro -------------------------------------------------------------*/
    
41. /* Private variables ---------------------------------------------------------*/
    
42. uint8_t GBuffer[FLASH_BLOCK_SIZE];
    
43. __IO TestStatus OperationStatus;
    
44. 
    
45. #ifdef _RAISONANCE_
    
46. /* needed by memcpy for raisonance */
    
47. #include <string.h>
    
48. extern int __address__FLASH_EraseBlock;
    
49. extern int __size__FLASH_EraseBlock;
    
50. extern int __address__FLASH_ProgramBlock;
    
51. extern int __size__FLASH_ProgramBlock;
    
52. #endif /*_RAISONANCE_*/
    
53. 
    
54. /* Private function prototypes -----------------------------------------------*/
    
55. /* Declare _fctcpy function prototype as it is packaged by default in the Cosmic
    
56.    machine library */
    
57. #ifdef _COSMIC_
    
58. int _fctcpy(char name);
    
59. #endif /*_COSMIC_*/
    
60. 
    
61. void Delay (uint16_t nCount);
    
62. static void CLK_Config(void);
    
63. static void GPIO_Config(void);
    
64. static void FLASH_Config(void);
    
65. /* Private functions ---------------------------------------------------------*/
    
66. 
    
67. /**
    
68.   * @brief  Main program.
    
69.   * @param  None
    
70.   * @retval None
    
71.   */
    
72. void main(void)
    
73. {
    
74.   uint32_t add = 0, startadd = 0, stopadd = 0;
    
75.   uint8_t newval = 0xAA;
    
76.   uint8_t i = 0;
    
77. 
    
78. #ifdef _COSMIC_
    
79. /* Call the _fctcpy() function with the first segment character as parameter
    
80.    "_fctcpy('F');"  for a manual copy of the declared moveable code segment
    
81.    (FLASH_CODE) in RAM before execution*/
    
82.   _fctcpy('F');
    
83. #endif /*_COSMIC_*/
    
84. 
    
85. #ifdef _RAISONANCE_
    
86. /* Call the standard C library: memcpy() or fmemcpy() functions available through
    
87.    the <string.h> to copy the inram function to the RAM destination address */
    
88.   MEMCPY(FLASH_EraseBlock,
    
89.          (void PointerAttr*)&__address__FLASH_EraseBlock,
    
90.          (int)&__size__FLASH_EraseBlock);
    
91.   MEMCPY(FLASH_ProgramBlock,
    
92.          (void PointerAttr*)&__address__FLASH_ProgramBlock,
    
93.          (int)&__size__FLASH_ProgramBlock);
    
94. #endif /*_RAISONANCE_*/
    
95. 
    
96. 
    
97.   /* Clock configuration -----------------------------------------*/
    
98.   CLK_Config();
    
99. 
    
100.   /* GPIO Configuration ------------------------------------------*/
     
101.   GPIO_Config();
     
102. 
     
103.   /* FLASH Configuration ------------------------------------------*/
     
104.   FLASH_Config();
     
105. 
     
106.   /* Fill the buffer in RAM */
     
107.   for (i = 0; i < FLASH_BLOCK_SIZE; i++)
     
108.   {
     
109.     GBuffer[i] = newval;
     
110.   }
     
111.   /* This function is executed from RAM */
     
112.   FLASH_ProgramBlock(BLOCK_OPERATION, FLASH_MEMTYPE_DATA, FLASH_PROGRAMMODE_STANDARD, GBuffer);
     
113.   
     
114.   /* Wait until End of high voltage flag is set*/
     
115.   while (FLASH_GetFlagStatus(FLASH_FLAG_HVOFF) == RESET)
     
116.   {}
     
117.   /* Check the programmed block */
     
118.   startadd = FLASH_DATA_START_PHYSICAL_ADDRESS + ((uint16_t)BLOCK_OPERATION * (uint16_t)FLASH_BLOCK_SIZE);
     
119.   stopadd = startadd + (uint16_t)FLASH_BLOCK_SIZE;
     
120.   for (add = startadd; add < stopadd; add++)
     
121.       {
     
122.         if (FLASH_ReadByte(add) != newval)
     
123.         {
     
124.           /* Error */
     
125.           OperationStatus = FAILED;
     
126.           /* OperationStatus = PASSED, if the data written/read to/from Flash program memory is correct */
     
127.           /* OperationStatus = FAILED, if the data written/read to/from Flash program memory is corrupted */
     
128.           while (1)
     
129.           {
     
130.             STM_EVAL_LEDToggle(LED1); /*FAIL: write error */
     
131.             Delay(0xFFFF);
     
132.           }
     
133.         }
     
134.       }
     
135.   /* Erase block 0 and verify it */
     
136.   /* This function is executed from RAM */
     
137.   FLASH_EraseBlock(BLOCK_OPERATION, FLASH_MEMTYPE_DATA);
     
138. 
     
139.   /* Wait until End of high voltage flag is set*/
     
140.   while (FLASH_GetFlagStatus(FLASH_FLAG_HVOFF) == RESET)
     
141.   {}
     
142. 
     
143.   for (add = startadd; add < stopadd; add++)
     
144.       {
     
145.         if (FLASH_ReadByte(add) != 0x00)
     
146.         {
     
147.           /* Error */
     
148.           OperationStatus = FAILED;
     
149.           /* OperationStatus = PASSED, if the data written/read to/from Flash program memory is correct */
     
150.           /* OperationStatus = FAILED, if the data written/read to/from Flash program memory is corrupted */
     
151.           while (1)
     
152.           {
     
153.             STM_EVAL_LEDToggle(LED2); /* FAIL: Erase error */
     
154.             Delay(0xFFFF);
     
155.           }
     
156.         }
     
157.       }
     
158. 
     
159.   /* Pass */
     
160.   OperationStatus = PASSED;
     
161.   /* OperationStatus = PASSED, if the data written/read to/from Flash program memory is correct */
     
162.   /* OperationStatus = FAILED, if the data written/read to/from Flash program memory is corrupted */
     
163.   while (1)
     
164.   {
     
165.     STM_EVAL_LEDToggle(LED3); /* PASS: without errors*/
     
166.     Delay(0xFFFF);
     
167.   }
     
168. }
     
169. 
     
170. /**
     
171.   * @brief  Configure system clock to run at 16Mhz
     
172.   * @param  None
     
173.   * @retval None
     
174.   */
     
175. void CLK_Config(void)
     
176. {
     
177.     /* Initialization of the clock */
     
178.     /* Clock divider to HSI/1 */
     
179.     CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
     
180. }
     
181. 
     
182. /**
     
183.   * @brief  Configure GPIO for LEDs available on the evaluation board
     
184.   * @param  None
     
185.   * @retval None
     
186.   */
     
187. void GPIO_Config(void)
     
188. {
     
189.     /* Initialize LEDs mounted on STM8-128 EVAL board */
     
190.     STM_EVAL_LEDInit(LED2);
     
191.     STM_EVAL_LEDInit(LED3);
     
192.     STM_EVAL_LEDInit(LED1);
     
193.                
     
194.                 /* All leds are Off */
     
195.     STM_EVAL_LEDOff(LED2);
     
196.     STM_EVAL_LEDOff(LED3);
     
197.     STM_EVAL_LEDOff(LED1);
     
198. }
     
199. 
     
200. /**
     
201.   * @brief  Configure the FLASH for block programming
     
202.   * @param  None
     
203.   * @retval None
     
204.   */
     
205. void FLASH_Config(void)
     
206. {
     
207. /* Define flash programming Time*/
     
208.   FLASH_SetProgrammingTime(FLASH_PROGRAMTIME_STANDARD);
     
209. 
     
210.   FLASH_Unlock(FLASH_MEMTYPE_PROG);
     
211.   /* Wait until Flash Program area unlocked flag is set*/
     
212.   while (FLASH_GetFlagStatus(FLASH_FLAG_PUL) == RESET)
     
213.   {}
     
214. 
     
215.   /* Unlock flash data eeprom memory */
     
216.   FLASH_Unlock(FLASH_MEMTYPE_DATA);
     
217.   /* Wait until Data EEPROM area unlocked flag is set*/
     
218.   while (FLASH_GetFlagStatus(FLASH_FLAG_DUL) == RESET)
     
219.   {}
     
220. }
     
221. 
     
222. /**
     
223.   * @brief  Delay.
     
224.   * @param  nCount
     
225.   * @retval None
     
226.   */
     
227. void Delay(uint16_t nCount)
     
228. {
     
229.     /* Decrement nCount value */
     
230.     while (nCount != 0)
     
231.     {
     
232.         nCount--;
     
233.     }
     
234. }
     
235. 
     
236. #ifdef  USE_FULL_ASSERT
     
237. /**
     
238.   * @brief  Reports the name of the source file and the source line number
     
239.   *   where the assert_param error has occurred.
     
240.   * @param  file: pointer to the source file name
     
241.   * @param  line: assert_param error line source number
     
242.   * @retval None
     
243.   */
     
244. void assert_failed(uint8_t* file, uint32_t line)
     
245. {
     
246.   /* User can add his own implementation to report the file name and line number,
     
247.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
248. 
     
249.   /* Infinite loop */
     
250.   while (1)
     
251.   {}
     
252. }
     
253. #endif
     
254. 
     
255. /**
     
256.   * @}
     
257.   */
     
258. 
     
259. /**
     
260.   * @}
     
261.   */
     
262. 
     
263. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码