01首先聊一聊
' _* e- v: i$ @$ j) D7 X, N( K大家都知道进行单片机编程和计算机编程有个最大的差别就是单片机的资源非常的有限，并且对于大部分低端单片机而言都没有操作系统。除了一些嵌入式级的芯片用了Linux系统外，其他大部分操作都是比较简单的RTOS，可能还有一些简单的应用或者芯片根本不用系统，直接是裸机程序。

0 v7 c* c+ k" ]& C. `5 j+ L不过大部分单片机编程都与硬件密切的结合，这样工程师能够对当前的项目对象有更多的把控能力和理解能力。但是由于它的简单，我们平时在工作中往往需要控制一个项目的成本，对于单片机的选型和资源的评估都是非常谨慎；同样随着我们项目功能的不断扩展，也会让系统程序逐步变得庞大，这时候资源的使用就更需要节约点用了。
3 G) }% N) E* f* `% b/ I+ _所以当资源受限制(一般的单片机RAM也就Kb级别),比如说单片机RAM不够了，即使你有再牛的算法可能也无法加入到项目中来，那么有些同志们会问，那换芯片不就可以了吗？我只想说这位同志你想多了，对于不怎么热卖产品或者不规范的公司可能还允许你试一试，可是一般的公司项目卡着走的，换了主控芯片，暂且不说软件上的移植工作，换了芯片成本上必定增加，产品的测试都得重新规划，老板领导可不愿意了。
& b4 J' G3 i3 W6 T; f/ \8 K5 X那么主控芯片换不了我们还有什么办法呢？那我们应该从原本的程序中挤出资源来使用了，下面我总结了几种常总方法供大家参考。(具体内容可以网络查找)

02

共联体-union

union-共联体，是C语言常用得关键字。从字面上的意思就是共同联合在一起的意思，union所有的成员共同维护一段能够内存空间，其内存的大小取决于所有成员中占用空间最大的成员。
union结构体由于是共用同一片内存可以大大节省内存空间，那一般什么情况下使用union?又或者union还有什么特点？下面我将用几点为大家解答。
! h" k. {: g( Q( `! X
1)所有的union的成员及本身的地址是一样的。
; ^4 w( k6 Q# R: N# e4 H5 P- C2)union的存储模型受大小端的影响，我们可以通过下面的代码进行测试。(如果输出结果为1，表示小端模式，否则为大端模式)

大端模式(Big_endian)：一个数据的高字节存储在低地址，低字节存储在高地址。其指针指向的首地址位于低地址。小端模式(Little_endian)：一个数据的高字节存储在高地址，低字节存储在低地址。其指针指向的首地址位于高地址。

3)union不同于结构体struct，union对成员的改变可能会影响到其他成员变量，所以我们要形成一种互斥使用，比如说我们的顺序执行其实就是每个代码都是互斥的，所以我们可以用union进行函数处理缓存等。(个人觉得也可以认为是分时复用，并且是不会受内存初值影响的处理)

1. 
   9 w* p% C5 B8 ?& P' {, E
2. #include<stdio.h>
   
3. 
   ) A" T4 O. ^4 t: w
4. typedef union _tag_test
   6 `9 G2 z; m9 o* }
5. {
   
6.   char a;
   
7.   int  b;
   
8. }uTest;
   
9. 
   # c/ _) W# v9 ?3 @& R
10. uTest test;
    + U0 S8 O. r5 ]  ]) t# ~
11. unsigned char Checktype(void);
    
12. 
    
13. int main(void)
    
14. {
    
15.     printf("%x\n",(unsigned int)&test.a);
    ) U5 Q, b3 s  z' F
16.     printf("%x\n",(unsigned int)&test.b);
    
17.     printf("%x\n",(unsigned int)&test);
    % E) C3 a0 [( B, t
18.     printf("%d\n",Checktype());
    5 L3 m& i$ E! j3 k+ I3 w; F, t, }
19. }
    * x5 i- z, X0 I" d6 T% K& K
20. unsigned char Checktype(void)
    
21. {
    ! v. ?3 \+ h8 g2 B# h
22.      uTest chk;
    
23.      chk.b = 0x01;
    
24.      if(chk.a == 0x01)return 1;
    $ R$ L( J" Q7 Y$ g6 d9 H+ F  v
25.      return 0;
    
26. }

复制代码

03

位域

位域可能对于初学者用得比较少，不过对于大部分参加工作的工程师应该屡见不鲜了，确实它也是我们省内存的神器。

% r" E8 Z6 J7 C6 z' {5 a) j; R6 Y因为在我们平时编程过程中，我们使用的变量与实际情况是息息相关的，就比如说开关的状态，我们一般就是0或者是1分别表示打开和关闭，那么我们用一个bit就能表示，假如说我们用一个char来存储就几乎浪费了7个bit，如果以后也有类似的的情况，那么大部分内存都得不到有效的应用。所以C语言的位域就是用来解决这个问题。
2 W$ A. J/ o, V' R$ O2 z不过我们需要注意如下几点：
3 L: t6 T3 e+ M" u' y( c1)位域是在结构体中实现的，其中位域规定的长度不能超过所定义类型，且一个位域只能定义在同一个存储单元中。
7 l/ n4 O% c  b1 f; N6 n2)无名位域的使用，可以看下面的代码。
3)由于位域与数据类型有关系，那么他的内存占用情况也与平台的位数相关。(相关内容可网络查找)

1. 
   0 u8 @6 J0 d7 e$ ?& S
2. #include<stdio.h>
   
3. //结果：编译通过
   
4. //原因：常规形式（结构体占用两个字节）
   1 h: x! [; |( D% o3 |
5. typedef struct _tag_test1
   
6. {
   
7.   char a:1;
   + l8 i" o1 w$ A+ |
8.   char b:1;
   ; Y. ~8 s4 c$ J3 D, n+ {
9.   char c:1;
   6 c; L& d/ b' o, Q
10.   char d:6;
    4 ]2 F; \9 v( l3 |+ w
11. }sTest1;
    0 ]  N+ K( ?6 i7 G
12. //结果：编译无法通过
    
13. //原因：d的位域长度10超过了char类型长度
    ' n' s( k7 `) ]# x# u! n: S
14. /*
    4 }) Y2 r) t5 P4 B/ q2 ^, _# A8 x
15. typedef struct _tag_test2
    
16. {
    
17.   char a:1;
    / A( R, f5 a6 C) S
18.   char b:1;
    
19.   char c:1;
    : T8 y" a. u# ]! H1 I: u
20.   char d:10;
    / `' {/ Z! R4 h9 P
21. }sTest2;
    
22. */
    & t' C& E" L% i1 C; e' M' F
23. //结果：编译可通过
    * {2 W" Y1 x* ?( d6 F/ `! s
24. //原因：下面使用无名位域，且占8个字节
      \. a' v4 l4 [7 |5 Y/ C' x" e, M
25. typedef struct _tag_test3
    
26. {
    2 ?+ c; s& k, h& c! n
27.   int a:1;
    
28.   int b:1;
    ) O% w( E1 G& I' D
29.   int :0;//无名位域
    
30.   int c:1;
    4 e: o, @6 q; _( o7 X0 H; o
31. }sTest3;
    ; h# D2 z9 Q; Z% k4 y4 D7 H7 a! Z
32. int main(void)
    0 N2 {! @/ W7 r+ x: i
33. {
    
34.     printf("%d\n",sizeof(sTest1));
    
35.     printf("%d\n",sizeof(sTest3));
    
36.     printf("欢迎关注公众号:最后一个bug\n");
    / m: J5 d) @) ]  i* I7 r' ~
37. }

复制代码

04

结构体对齐

% c' B' {6 J) j

结构体对齐问题可能大部分人关注的不是很多，可能在通讯领域进行内存的copy时候接触得比较多。结构体对齐问题也是与平台相关，CPU为了提高访问内存的效率，一次性可能读取2个字节，4个字节，8个字节等，所以编译器会自动对结构体内存进行对齐。
7 k& F  D; Q1 `7 `废话不多说，代码说明一切：
. Y* n' l- y$ _" Y  C0 H! d, q

1. 
   1 {8 w& N! J9 m- j, d: y+ T
2. #include<stdio.h>
   + l7 j" z8 `5 m/ W+ w: {/ D
3. #pragma pack(1)
   
4. //有字节对齐预编译结果为：12，8
   % q" z8 B& @8 W) N. M
5. //无字节对齐预编译结果为：6，6
   
6. typedef struct _tag_test1{
   
7.     char a;
   $ E- }. O$ w) P4 {4 V
8.     int  b;
   
9.     char c;
   
10. 
    6 @9 m, M* X" e3 A3 N
11. }STest1;
    
12. 
    
13. typedef struct _tag_test2{
    
14.     int  b;
    4 d  p/ @+ o) D- X7 m( A4 [# u3 D. y
15.     char a;
    & r" l, ^5 H, D4 Q2 F, \4 m7 ]. z
16.     char c;
    - I( b5 L# {2 M7 m$ o3 q+ W
17. 
    / g+ T! m9 u* Q3 e3 `
18. }STest2;
    : t' l1 U* j2 X  J/ e9 Y5 v" L
19. 
    
20. int main(void)
    
21. {
    
22.     printf("%d\n",sizeof(STest1));
    
23.     printf("%d\n",sizeof(STest2));
    ( [" v" |3 w9 w! }2 }) P; W0 u
24.     printf("欢迎关注公众号:最后一个bug\n");
    # X- n0 e, i6 N3 z- J
25. }

复制代码

05

算法优化

算法优化其实主要是我们通过修改一些算法的实现一种效率与内存使用的一个平衡，我们都知道我们的算法都存在着复杂度的问题，我们大部分高效率的算法都是通过使用内存来换效率，也就是一种用空间换时间的概念。那么当我们内存使用有限的时候我们可以适当的用时间来换空间的方法，腾出更多的空间来实现更多的功能。

# K, {7 I0 t1 V- i5 w0 {, |5 w8 X7 o同样我们在进行相关设计的时候可以尽量使用局部变量来减少全局变量的使用！

06

利用const

1、const的使用
+ F! [- |4 i- Z8 e( i4 h关于const的用法应该是老生常谈的知识点了，如果还有不是特别清楚的小伙伴可以参考<一文搞定C语言const关键字>一文,bug菌就不重复造轮子了，直接以stm32单片机为例看看const变量的的存储方式。

参考demo：

1. 
   
2. #include "led.h"
   3 S8 e* ?5 [: M! D9 i" v6 I& p  c
3. #include "delay.h"
   7 E& A/ V/ d$ G- Z8 d
4. #include "usart.h"
   
5. 
   7 ^  N$ @( {! M0 k" `, k/ Q
6. #define DEV_NUM_MAX   (3)
   / X0 D  [4 U$ v* }5 C' u
7. #define DEV_PARAM_MAX (2)
   ! r  }# x+ x* ?$ A# e4 i
8. 
   ( [" o. z, K* V# l: B. u
9. typedef struct _tag_DevParam
   2 @* y& `7 L, p3 G4 p
10. {
    
11.     char* Name;                     //设备名称
    
12.     uint32_t Param[DEV_PARAM_MAX];  //设备参数
    5 w7 z6 q. Y: f% H! f# w; G3 p
13. }sDevParam;
    
14. 
    
15. 
    3 g( ?3 q& G+ l4 S
16. const sDevParam stDevParam[DEV_NUM_MAX] = {
    2 f8 n/ U: G7 H' y# T4 q0 O
17.                                 {"Uart1",57600,0},
    " f. Y7 f: i2 }: `( S# p2 O
18.                                 {"Uart2",57600,1},
    
19.                                 {"CAN",1000000,0},
    4 w4 d4 y4 P" F2 F1 y% N, J% W
20.                                 };
    * u: W% g, C8 q3 ^% X
21. /***************************************
    1 i  s" _5 a! q; Q
22. * Fuction：const内存分配测试
    7 f0 V: _7 p0 t
23. * Author ：bug菌                                
    
24. **************************************/
    5 V6 Y1 q  M& x0 l* K$ a3 \
25. int main(void)
    
26. {
    
27.     uint8_t t = 0;
    7 i" T- L9 L6 R2 p
28.     uint8_t devCnt = 0;
    - O4 i8 D  Q" v! ]! e* U% g
29. 
    
30.     delay_init();            //延时函数初始化   
    " ]- f. q1 a  ^! U4 w8 t' c& y% ?
31.     uart_init(115200);   //串口初始化
    / ?# X$ v# B. z' {  \( I- c
32. 
    
33.     printf("\n*******************const Test*******************\r\n");
    
34. 
    $ d; T# q7 G0 \" P
35.     for(devCnt = 0 ;devCnt < DEV_NUM_MAX;devCnt++)
    
36.     {
    
37.         printf("DevName = %s,Param1 = %d,Param2 = %d\r\n",stDevParam[devCnt].Name,\
    
38.                                                       stDevParam[devCnt].Param[0],\
    
39.                                                       stDevParam[devCnt].Param[1]);
    
40.     }
    
41.     printf("stDevParam Size : %d \r\n",sizeof(stDevParam));
    5 H& Z' n6 ?. a" G) ^; ~6 G1 S% o0 W1 v
42.     printf("stDevParam Addr : 0x%X \r\n",stDevParam);
    ; f6 G: ~% n3 m+ X
43.     printf("\n***********欢迎关注公众号:最后一个bug************\n");
    0 o) Y4 o2 y% i/ `& f
44.     while(1)
    3 Z/ a6 h" p- k7 N* @' n7 I  e6 x
45.     {
    
46.         delay_ms(10);
    ( z! U" o' I$ q  G) G, k
47.         if(++t > 150){LED0=0;}else{LED0=1;}
    
48.     }   
    
49. }

复制代码

8 I: U5 d9 I3 K; b5 v; |  w& d

运行结果：

分析一下：

• 对于stm32的所有存储映像都在对应工程所编译生成的.map文件中，对.map文件(其文件在工程目录中)的熟悉度就在一定程度上彰显你对stm32单片机的熟练程度。
• 程序编译成功以后，就可以直接在map文件中查找const修饰的数组名，从而得到如下结果:
  : s4 ]0 J- `2 ~

2 N0 D, b* b" M7 H( m

• 从上图我们了解到其stDevParam变量位置0x080016b8数据区且位于（.contdata段--只读数据段）并占用了36个字节，与我们串口输出结果是相符合的。
  8 h# @$ c' c% X% O( t
  + u. C6 ~0 H1 j% m

2、const数据的存储
0 \( L* y+ P5 d6 W通过上面的测试程序显示了const数据的存储位置，那么我们看一下该位置位于stm32的哪块存储区域，是RAM还是FLASH？
因为我们节省内存主要就是通过占用更小的RAM来实现相同的项目需求，那么对于MCU而言最好就是的借助Flash，通过时间来置换空间，拿出对应的数据手册看看这些存储范围是如何分配的。
上图来源于ST手册Memory Mapping
. L, m* B7 L) r' T  s很明显前一节测试的const stDevParam变量位置0x080016b8处，正好处于FLASH存储位置，所以其并没有占用RAM资源。
3、const数据使用
很多写单片机程序的小伙伴都喜欢把一些只读的变量用全局变量来保存，然而这些变量基本上只保存一些参数，这对于单片机的RAM资源是非常浪费的。
2 a7 c2 U0 K2 v5 rbug菌曾经接手过一个前同事项目，怎么说呢?可能这个项目他也是接手别人的，该项目MCU还外部扩展了一个16M的SDRAM，大家都觉得反正RAM大，变量随便定，也不去管数据范围，动不动就float，double，真的是牛。
# v$ t  }( t" ^6 U! I/ `) \直到bug菌接手内存占用率已高达95%，后面稍微添加一些需求感觉RAM就要爆掉了，没办法这样下去终究会出问题，于是申请了代码重构，通过优化代码结构、设计等RAM占用率直接降到了50%左右，可以想象一下之前的开发人员是多么的任性。
所以一句话说得好"前人栽树，后人乘凉；前人挖坑，后人入fen"。前面我们分析了stm32的const数据位于Flash上，一般Flash都会比RAM打上好几倍:（如下图所示:）
/ E8 u9 j+ H& Z3 `2 v 上图来源于ST官网
- @/ t' \$ ?- p5 u这样对于一些预先设置好的参数等等都可以整理以后统一放到类似于前面demo中这样的结构体数组中，从而可以大大减少对RAM的占用。
7 N7 b5 N9 ?; F" T1 i; d$ n9 [8 P注意一点的是 : 访问RAM一般来说会比访问Flash要快一些，然而大部分项目对于这样的差异影响非常之小，后面bug菌会为大家再带来一篇文章讲讲这块的知识。
. H0 S$ A- g# N5 C& _  |