21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › c语言中定义的全局变量，在某个函数中赋值还能被其他函 ...
12下一页
返回列表 发新帖我要提问

c语言中定义的全局变量，在某个函数中赋值还能被其他函数使用吗？

[复制链接]
21744|21
 楼主| jiangsai 发表于 2013-4-26 16:43 | 显示全部楼层 |阅读模式
C语言, 全局变量, 函数
为了省下参数传递的麻烦，我把一些多个函数都要用到的变量和结构体都定义成全局的，可以吗？为什么我的程序执行时出现问题，查看修改后的全局变量值没有改变，还是初始值 呢？请各位高手指点。我在一个函数中对全局变量自加运算，再到另一个函数中全局变量值是开始的初值还是上一个函数自加后的值呢？
回复

收藏 举报

相关帖子
杨爱林林 发表于 2013-4-26 16:52 | 显示全部楼层
当然是可以用的了 而且比较方便  
如果你没带系统的话  就看使用这个全局变量的先后顺序了  全局变量，当然是最后使用该变量过后的值了 也就是自加过后的值
如果带系统的话  就得保护这个共享资源了  
你可以贴上代码
回复

收藏 举报

uet_cache 发表于 2013-4-26 16:56 | 显示全部楼层
全局变量，要放在程序开头位置。如果其它文件要用，要声明外部变量。
回复

收藏 举报

airwill 发表于 2013-4-26 18:25 | 显示全部楼层
全局变量, 当然是可以的.
不过, 我们写程序, 不建议大量使用全局变量.
"我在一个函数中对全局变量自加运算，再到另一个函数中全局变量值是开始的初值还是上一个函数自加后的值呢？"  当然是后者. 这里可能有个概念问题. 假如以变量传递给函数了. 那么修改的是个传递过来的副本, 而不是本身. 除非传递全局变量的地址.
回复

收藏 举报

hawksabre 发表于 2013-4-26 19:02 | 显示全部楼层
大量使用全局函数   最终程序的改动就是牵一发动全身    不建议使用过多全局函数    模块化的思想倒是不错的思想   楼主   可以借鉴一下
回复

收藏 举报

hawksabre 发表于 2013-4-26 19:02 | 显示全部楼层
多看看关于编程思想的书籍   我也是班门弄斧    飘过  
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 07:58 | 显示全部楼层
杨爱林林 发表于 2013-4-26 16:52
当然是可以用的了 而且比较方便  
如果你没带系统的话  就看使用这个全局变量的先后顺序了  全局变量，当然 ...

我在做小的毕业设计，没带系统。。并且只有设了一个全局变量，在main。c的开头设置的。。后面的函数要用到该变量的话要怎么应用呢。。
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 07:59 | 显示全部楼层
uet_cache 发表于 2013-4-26 16:56
全局变量，要放在程序开头位置。如果其它文件要用，要声明外部变量。

只是在该文件中使用，
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 08:04 | 显示全部楼层
airwill 发表于 2013-4-26 18:25
全局变量, 当然是可以的.
不过, 我们写程序, 不建议大量使用全局变量.
"我在一个函数中对全局变量自加运算 ...

我想了想可以把所有的子函数都放进main中可以用设全局变量了。。但那样字话，程序就不够好看了。。所以我还是想把子函数放到外面，main中调用。。但全局变量我用不好呢。。在子函数中引用全局变量的话，要做舍呢么特别的说明吗。。代码我一会贴上去。我想实现的就是一个简单的一个按键可以先设定下圈数，按下另外的按键就可以左转或右转相应的圈数
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 08:07 | 显示全部楼层
复制
  1. /* Includes ------------------------------------------------------------------*/
    

  2. #include "stm32f10x.h"
    

  3. #include "stm32_eval.h"
    

  4. #include <stdio.h>
    

  5. //#include "ARMJISHU_TouchScreen_ADS7843.h"
    

  6. #include "sys.h"                
    

  7.         
    

  8. void USART_Configuration(void);
    

  9. void RCC_Configuration(void);
    

  10. void GPIO_Configuration(void);
    

  11. void Delay(vu32 nCount);
    

  12. void Delay1(vu32 nCount);
    

  13.  u8 M=0;
    

  14. /* Values magic to the Board keys */
    

  15. #define  NOKEY  0
    

  16. #define  KEY1   1
    

  17. #define  KEY2   2
    

  18. #define  KEY3   3
    

  19. #define  KEY4   4
    

  20. #define  KEY5   5            
    

  21. #define  KEY6   6            
    


  22. 

  23. /*按键相关定义*/
    

  24. #define RCC_KEY1                                    RCC_APB2Periph_GPIOB
    

  25. #define GPIO_KEY1_PORT                              GPIOB    
    

  26. #define GPIO_KEY1                                   GPIO_Pin_0
    

  27. #define RCC_KEY2                                    RCC_APB2Periph_GPIOB
    

  28. #define GPIO_KEY2_PORT                              GPIOB 
    

  29. #define GPIO_KEY2                                   GPIO_Pin_1
    

  30. #define RCC_KEY3                                    RCC_APB2Periph_GPIOB
    

  31. #define GPIO_KEY3_PORT                              GPIOB
    

  32. #define GPIO_KEY3                                   GPIO_Pin_2
    

  33. #define RCC_KEY4                                    RCC_APB2Periph_GPIOB
    

  34. #define GPIO_KEY4_PORT                              GPIOB
    

  35. #define GPIO_KEY4                                   GPIO_Pin_5
    

  36. #define RCC_KEY5                                    RCC_APB2Periph_GPIOB
    

  37. #define GPIO_KEY5_PORT                              GPIOB
    

  38. #define GPIO_KEY5                                   GPIO_Pin_6
    

  39. #define RCC_KEY6                                    RCC_APB2Periph_GPIOB
    

  40. #define GPIO_KEY6_PORT                              GPIOB
    

  41. #define GPIO_KEY6                                   GPIO_Pin_7
    


  42. 

  43. /* Private function prototypes -----------------------------------------------*/
    

  44. #ifdef __GNUC__
    

  45. /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
    

  46.                                              set to 'Yes') calls __io_putchar() */
    

  47.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    

  48. #else
    

  49.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    

  50. #endif /* __GNUC__ */
    

  51.   
    

  52. /*static void Delay_ARMJISHU(__IO uint32_t nCount)
    

  53. {
    

  54.   for (; nCount != 0; nCount--)
    

  55.   {
    

  56.       if(GPIO_ADS7843_INT_VALID)
    

  57.       {
    

  58.         ARMJISHU_TouchScreen_ADS7843();
    

  59.       }        
    

  60.   }
    

  61. }                                                   */
    


  62. 

  63. void delay(void)
    

  64.   {
    

  65.       unsigned long ik ;
    

  66.       for(ik=0;ik<0x03af8;ik++) ;
    

  67.   }
    

  68. void delay1(void)
    

  69.   {
    

  70.       unsigned long ik ;
    

  71.       for(ik=0;ik<0x00af8;ik++) ;
    

  72.   }
    


  73. 

  74. /* Private functions ---------------------------------------------------------*/
    


  75. 

  76. /*******************************************************************************
    

  77. * Function Name  : GPIO_KEY_Config.
    

  78. * Description    : Configures the Extension Button.
    

  79. * Input          : None.
    

  80. * Output         : None.
    

  81. * Return         : None.
    

  82. *******************************************************************************/
    

  83. void GPIO_KEY_Config(void)
    

  84. {
    

  85.   GPIO_InitTypeDef GPIO_InitStructure;
    


  86. 

  87.   /* Configure KEY1 Button */
    

  88.   RCC_APB2PeriphClockCmd(RCC_KEY1, ENABLE);
    


  89. 

  90.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    

  91.   GPIO_InitStructure.GPIO_Pin = GPIO_KEY1;
    

  92.   GPIO_Init(GPIO_KEY1_PORT, &GPIO_InitStructure);
    

  93.     /* Configure KEY2 Button */
    

  94.   RCC_APB2PeriphClockCmd(RCC_KEY2, ENABLE);
    


  95. 

  96.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    

  97.   GPIO_InitStructure.GPIO_Pin = GPIO_KEY2;
    

  98.   GPIO_Init(GPIO_KEY2_PORT, &GPIO_InitStructure);
    

  99.       /* Configure KEY3 Button */
    

  100.   RCC_APB2PeriphClockCmd(RCC_KEY3, ENABLE);
    


  101. 

  102.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    

  103.   GPIO_InitStructure.GPIO_Pin = GPIO_KEY3;
    

  104.   GPIO_Init(GPIO_KEY3_PORT, &GPIO_InitStructure);
    

  105.         /* Configure KEY4 Button */
    

  106.   RCC_APB2PeriphClockCmd(RCC_KEY4, ENABLE);
    


  107. 

  108.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    

  109.   GPIO_InitStructure.GPIO_Pin = GPIO_KEY4;
    

  110.   GPIO_Init(GPIO_KEY4_PORT, &GPIO_InitStructure);
    

  111.         /* Configure KEY5 Button */
    

  112.   RCC_APB2PeriphClockCmd(RCC_KEY5, ENABLE);
    


  113. 

  114.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    

  115.   GPIO_InitStructure.GPIO_Pin = GPIO_KEY5;
    

  116.   GPIO_Init(GPIO_KEY5_PORT, &GPIO_InitStructure);
    

  117.         /* Configure KEY6 Button */
    

  118.    RCC_APB2PeriphClockCmd(RCC_KEY6, ENABLE);
    


  119. 

  120.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    

  121.   GPIO_InitStructure.GPIO_Pin = GPIO_KEY6;
    

  122.   GPIO_Init(GPIO_KEY6_PORT, &GPIO_InitStructure);
    

  123. }
    

  124. /*******************************************************************************
    

  125. * Function Name  : ReadKey
    

  126. * Description    : Reads key from demoboard.
    

  127. * Input          : None
    

  128. * Output         : None
    

  129. * Return         : Return RIGHT, LEFT, SEL, UP, DOWN or NOKEY
    

  130. *******************************************************************************/
    

  131. u8 ReadKeyDown(void)
    

  132. {
    

  133.   /* 1 key is pressed */
    

  134.   if(!GPIO_ReadInputDataBit(GPIO_KEY1_PORT, GPIO_KEY1))
    

  135.   {
    

  136.     return KEY1; 
    

  137.   }        
    

  138.     /* 2 key is pressed */
    

  139.  else if(!GPIO_ReadInputDataBit(GPIO_KEY2_PORT, GPIO_KEY2))
    

  140.   {
    

  141.     return KEY2; 
    

  142.   }
    

  143.    /* 3 key is pressed */
    

  144.  else if(!GPIO_ReadInputDataBit(GPIO_KEY3_PORT, GPIO_KEY3))
    

  145.   {
    

  146.     return KEY3; 
    

  147.   }
    

  148.  
    

  149.    /* 4 key is pressed */
    

  150.  else if(!GPIO_ReadInputDataBit(GPIO_KEY4_PORT, GPIO_KEY4))
    

  151.   {
    

  152.     return KEY4; 
    

  153.   }                  
    

  154.     /* 5 key is pressed */
    

  155. else if(!GPIO_ReadInputDataBit(GPIO_KEY5_PORT, GPIO_KEY5))
    

  156.   {
    

  157.     return KEY5; 
    

  158.   }
    

  159.    /* 6 key is pressed */
    

  160. else if(!GPIO_ReadInputDataBit(GPIO_KEY6_PORT, GPIO_KEY6))
    

  161.   {
    

  162.     return KEY6; 
    

  163.   }  
    

  164.   /* No key is pressed */
    

  165.   else 
    

  166.   {
    

  167.     return NOKEY;
    

  168.   }
    

  169. }
    


  170. 

  171. void motor_Turn_on_1(void)                 //正转
    

  172. {
    

  173.                               GPIO_Write(GPIOA, 0x08);
    

  174.                                                       delay();
    

  175.                                                       GPIO_Write(GPIOA,0x0C);
    

  176.                                                       delay();
    

  177.                                                       GPIO_Write(GPIOA,0x04);
    

  178.                                                       delay();
    

  179.                                                       GPIO_Write(GPIOA,0x06);
    

  180.                                                       delay();        
    

  181.                                                           GPIO_Write(GPIOA, 0x02);
    

  182.                                                       delay();
    

  183.                                                           GPIO_Write(GPIOA, 0x03);
    

  184.                                                       delay(); 
    

  185.                                                           GPIO_Write(GPIOA, 0x01);
    

  186.                                                       delay();
    

  187.                                                            GPIO_Write(GPIOA, 0x09);
    

  188.                                                       delay();
    

  189. }
    

  190.  void motor_Turn_on_2(void)                 //反转
    

  191. {
    

  192.                               GPIO_Write(GPIOA,0x09);
    

  193.                                                       delay(); 
    

  194.                                                           GPIO_Write(GPIOA,0x01);
    

  195.                                                       delay(); 
    

  196.                                                           GPIO_Write(GPIOA,0x03);
    

  197.                                                       delay();
    

  198.                                                       GPIO_Write(GPIOA,0x02);
    

  199.                                                       delay(); 
    

  200.                                                           GPIO_Write(GPIOA, 0x06);
    

  201.                                                       delay();        
    

  202.                                                            GPIO_Write(GPIOA, 0x04);
    

  203.                                                       delay();
    

  204.                                                            GPIO_Write(GPIOA, 0x0C);
    

  205.                                                       delay();
    

  206.                                                            GPIO_Write(GPIOA, 0x08);
    

  207.                                                       delay();        
    

  208. }
    

  209.  void motor_Turn_on_3(void)                //         正转一圈
    


  210. 

  211. {
    

  212.   u8 j;
    

  213.   u8 r;
    

  214.   u8 N=64;
    


  215. 

  216.   for(r=0;r<N*M;r++)
    

  217.   {
    

  218.   for(j=0;j<8;j++)                 //电机外轴旋转一周，不是里里面面所看到的一周
    

  219.   {
    

  220.                               GPIO_Write(GPIOA, 0x08);
    

  221.                                                       delay();
    

  222.                                                       GPIO_Write(GPIOA,0x0C);
    

  223.                                                       delay();
    

  224.                                                       GPIO_Write(GPIOA,0x04);
    

  225.                                                       delay();
    

  226.                                                       GPIO_Write(GPIOA,0x06);
    

  227.                                                       delay();        
    

  228.                                                           GPIO_Write(GPIOA, 0x02);
    

  229.                                                       delay();
    

  230.                                                           GPIO_Write(GPIOA, 0x03);
    

  231.                                                       delay(); 
    

  232.                                                           GPIO_Write(GPIOA, 0x01);
    

  233.                                                       delay();
    

  234.                                                           GPIO_Write(GPIOA, 0x09);
    

  235.                                                       delay();
    


  236. 

  237.   }
    

  238. }
    

  239. M=0;
    

  240. }
    

  241.  void motor_Turn_on_4(void)                //         反转一圈
    

  242. {
    

  243.   u8 j;
    

  244.   u8 r;
    

  245.   u8 N=64;
    

  246.   
    

  247.   for(r=0;r<N*M;r++)
    

  248.   {
    

  249.    
    

  250.   for(j=0;j<8;j++)                 //电机外轴旋转一周，不是里里面面所看到的一周
    

  251.   {
    

  252.     GPIO_Write(GPIOA,0x09);
    

  253.         delay(); 
    

  254.         GPIO_Write(GPIOA,0x01);
    

  255.         delay(); 
    

  256.         GPIO_Write(GPIOA,0x03);
    

  257.         delay();
    

  258.         GPIO_Write(GPIOA,0x02);
    

  259.         delay(); 
    

  260.     GPIO_Write(GPIOA, 0x06);
    

  261.         delay();        
    

  262.         GPIO_Write(GPIOA, 0x04);
    

  263.         delay();
    

  264.         GPIO_Write(GPIOA, 0x0C);
    

  265.         delay();
    

  266.         GPIO_Write(GPIOA, 0x08);
    

  267.         delay();        
    

  268.   }
    

  269. }
    

  270. M=0;
    

  271. }
    

  272.    void num1(void)                
    

  273. {
    


  274. 

  275.  M=M+1;
    

  276.  
    

  277. }
    

  278. /*void num2(void)                
    

  279. {
    

  280.  if(M<=0) 
    

  281.  {
    

  282.  M=1  ;
    

  283.  }
    

  284.   M=M-1;
    

  285. }          */
    

  286.  void motor_ccw00(u8 key)
    

  287.   {
    

  288.    
    

  289.         /* Turn Off Select LED */
    

  290.     switch(key)
    

  291.     {
    

  292.           case 0:
    

  293.                  
    

  294.           motor_Turn_on_1();   //反转
    

  295.           break;
    


  296. 

  297.         case 1:
    

  298.                  
    

  299.           motor_Turn_on_2();         //正转
    

  300.           break;
    


  301. 

  302.         case 2:                                        //反转n圈
    

  303.                  
    

  304.           motor_Turn_on_3();
    

  305.           break;
    


  306. 

  307.         case 3:
    

  308.                 
    

  309.          motor_Turn_on_4();                //正转n圈
    

  310.          break;
    

  311.        case 4:
    

  312.                  num1();
    

  313.                                  
    

  314.          break; 
    

  315.         /*         case 5:
    

  316.                  num2();
    

  317.                   motor_Turn_on_4();                
    

  318.          break;                            */
    

  319.         default:
    

  320.           GPIO_ResetBits(GPIOA, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
    

  321.           break;
    

  322.     }
    

  323.  
    

  324. }   
    

  325. int main(void)
    

  326. {                        
    

  327. //        int m=2, n=1;
    

  328.     u8 KeyNum = 0;
    

  329.         #ifdef DEBUG
    

  330.         debug();
    

  331.     #endif        
    


  332. 

  333.         USART_Configuration();         //必须放在前面
    

  334.         RCC_Configuration();
    

  335.         GPIO_Configuration();
    

  336.     GPIO_KEY_Config();
    

  337. //        ADS7843_Init();        
    


  338. 

  339.     while (1)
    

  340.    {
    

  341.                 KeyNum=ReadKeyDown();
    

  342.                    motor_ccw00(KeyNum-1);
    

  343.              
    

  344.     }         
    

  345. }
    


  346. 

  347. void USART_Configuration(void)
    

  348. {
    

  349.      USART_InitTypeDef USART_InitStructure;
    


  350. 

  351.      USART_InitStructure.USART_BaudRate = 115200;
    


  352. 

  353.          USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    


  354. 

  355.          USART_InitStructure.USART_StopBits = USART_StopBits_1;
    


  356. 

  357.           USART_InitStructure.USART_Parity = USART_Parity_No;
    


  358. 

  359.          USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    


  360. 

  361.          USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        
    


  362. 

  363.          STM_EVAL_COMInit(COM1, &USART_InitStructure);
    

  364. }          
    


  365. 

  366. void RCC_Configuration()
    

  367. {
    

  368.          //定义错误状态变量
    

  369.          ErrorStatus HSEStartUpStatus;
    

  370.         
    

  371.          //将RCC寄存器重新设置为默认值
    

  372.          RCC_DeInit();
    

  373.  
    

  374.          //打开外部高速时钟晶振
    

  375.          RCC_HSEConfig(RCC_HSE_ON);
    

  376.  
    

  377.          //等待外部高速时钟晶振工作
    

  378.          HSEStartUpStatus = RCC_WaitForHSEStartUp();
    

  379.          if(HSEStartUpStatus == SUCCESS)
    

  380.          {
    

  381.                  //设置AHB时钟(HCLK)为系统时钟
    

  382.                  RCC_HCLKConfig(RCC_SYSCLK_Div1);
    

  383.  
    

  384.                  //设置高速AHB时钟(APB2)为HCLK时钟
    

  385.                  RCC_PCLK2Config(RCC_HCLK_Div1);
    

  386.  
    

  387.                  //设置低速AHB时钟(APB1)为HCLK的2分频
    

  388.                  RCC_PCLK1Config(RCC_HCLK_Div2);
    

  389.                 
    

  390.                  //设置FLASH代码延时
    

  391.                  FLASH_SetLatency(FLASH_Latency_2);
    

  392.  
    

  393.                  //使能预取指缓存
    

  394.                  FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
    

  395.  
    

  396.                  //设置PLL时钟，为HSE的9倍频 8MHz * 9 = 72MHz
    

  397.                  RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
    

  398.  
    

  399.                   //使能PLL
    

  400.                  RCC_PLLCmd(ENABLE);
    

  401.  
    

  402.                  //等待PLL准备就绪
    

  403.                  while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
    

  404.  
    

  405.                  //设置PLL为系统时钟源
    

  406.                  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
    

  407.  
    

  408.                  //判断PLL是否是系统时钟
    

  409.                  while(RCC_GetSYSCLKSource() != 0x08);
    

  410.          }
    

  411.  
    

  412.          //开启TIM3的时钟
    

  413.          RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
    

  414.          //开启GPIOB的时钟和复用功能
    

  415.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO,ENABLE);
    

  416.  
    

  417. }
    

  418.  
    

  419. void GPIO_Configuration()
    

  420. {
    

  421.          GPIO_InitTypeDef GPIO_InitStructure;
    

  422.  
    

  423.           RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//打开外设A,的时钟
    


  424. 

  425.          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
    


  426. 

  427.          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//IO口的方向
    


  428. 

  429.          GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    


  430. 

  431.          GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化外设0,1,2,3,6的端口
    

  432. }
    

  433.  
    

  434. /**
    

  435.   * [url=home.php?mod=space&uid=247401]@brief[/url]  Retargets the C library printf function to the USART.
    

  436.   * @param  None
    

  437.   * @retval None
    

  438.   */
    

  439. PUTCHAR_PROTOTYPE
    

  440. {
    

  441.   /* Place your implementation of fputc here */
    

  442.   /* e.g. write a character to the USART */
    

  443.   USART_SendData(EVAL_COM1, (uint8_t) ch);
    


  444. 

  445.   /* Loop until the end of transmission */
    

  446.   while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TC) == RESET)
    

  447.   {
    

  448.   }
    


  449. 

  450.   return ch;
    

  451. }
    


  452. 

  453. #ifdef  USE_FULL_ASSERT
    


  454. 

  455. /**
    

  456.   * @brief  Reports the name of the source file and the source line number
    

  457.   *         where the assert_param error has occurred.
    

  458.   * @param  file: pointer to the source file name
    

  459.   * @param  line: assert_param error line source number
    

  460.   * @retval None
    

  461.   */
    


  462. 

  463. void assert_failed(uint8_t* file, uint32_t line)
    

  464. { 
    

  465.   /* User can add his own implementation to report the file name and line number,
    

  466.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
    

  467.   /* Infinite loop */
    

  468.   while (1)
    

  469.   {
    

  470.   }
    

  471. }
    

  472. #endif
    

  473. /**
    

  474.   * @}
    

  475.   */ 
    


  476. 

  477. /**
    

  478.   * @}
    

  479.   */ 
    

  480. /******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE****/
楼主小白一只，只为潜心做毕业设计，，可能会有很多问题，虚心听取大家的指正，多谢各位了。。
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 08:27 | 显示全部楼层
好像那个M在加一后，在下一个函数中引用时M还是保持着初始值0，
回复

收藏 举报

mmuuss586 发表于 2013-4-27 08:35 | 显示全部楼层
1、可以；
2、是不是定义了一个常量；
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 08:37 | 显示全部楼层
外出一下，下午回来回你们
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 08:38 | 显示全部楼层
mmuuss586 发表于 2013-4-27 08:35
1、可以；
2、是不是定义了一个常量；

是全局变量，你看看那个M为什么在下面的函数应用中还是初值0
回复

收藏 举报

杨爱林林 发表于 2013-4-27 08:38 | 显示全部楼层
jiangsai 发表于 2013-4-27 07:58
我在做小的毕业设计，没带系统。。并且只有设了一个全局变量，在main。c的开头设置的。。后面的函数要用 ...

你在main.c里面定义全局变量  U8 m=0；
在其他文件中想用的话  只要  extern u8 m;
就好了
还有 你确定 执行过m=m+1；那句了吗
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 19:47 | 显示全部楼层
杨爱林林 发表于 2013-4-27 08:38
你在main.c里面定义全局变量  U8 m=0；
在其他文件中想用的话  只要  extern u8 m;
就好了

反正按键按了，但m的值好像始终都是初值
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 19:48 | 显示全部楼层
杨爱林林 发表于 2013-4-27 08:38
你在main.c里面定义全局变量  U8 m=0；
在其他文件中想用的话  只要  extern u8 m;
就好了

其实我觉得就是这个地方粗了问题
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-27 19:52 | 显示全部楼层
杨爱林林 发表于 2013-4-27 08:38
你在main.c里面定义全局变量  U8 m=0；
在其他文件中想用的话  只要  extern u8 m;
就好了

我是不想多次使用调用，所以定义了个全局变量。。希望在下次用到M值时用到的是这次M变化之后的值，但实际没有达到那样子的效果。。请问下是什么原因呢
回复

收藏 举报

杨爱林林 发表于 2013-4-27 21:07 | 显示全部楼层
你在m=m+1；设个断点吧
个人感觉 你程序没执行那步
回复

收藏 举报

 楼主| jiangsai 发表于 2013-4-28 09:27 | 显示全部楼层
杨爱林林 发表于 2013-4-27 21:07
你在m=m+1；设个断点吧
个人感觉 你程序没执行那步

如何设置断点呢，我先百度下。。
回复

收藏 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

jiangsai

4

主题

49

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部