【重磅】在这 一芯难求 各种涨价的时代，STM32G0闪亮登场了........

由于芯片制造工艺的区别，STM32G0被委以重任，撑起一片天，据我从官方了解的情况可以得出一个结论，不管从价格上还是从性能上STM32G0都可以用来代替STM32F0，我们话不多说直接来看看它的区别：

一：我们从外部封装引脚上来看

G0没有F0的100PIN的封装，但是它增加了SO8封装的引脚，这样的话性能很强大，价格很有诱惑力，极具性价比。

二：我们从外设配置资源来看:

1. 内核更高级：F0:Cortex-M0内核，主频高达48MHZ；G0:Cortex-M0+内核，主频高达64MH，主频高，程序运行更快！

2. G0的FLASH存储器方面有缩小，SRAM方面有扩展。

4.  ADC速率更高，F0:ADC时钟频率提高到14Mhz，G0:ADC时钟频率提高到16Mhz，G0的AD模拟采样转换速率更快。举例：（1.5为采样周期，12.5为转换周期）

G0：With ADC_CLK = 16 MHz and a sampling time of 1.5 ADC clock cycles:

Tconv = 1.5 + 12.5 = 14 ADC clock cycles = 0.875 µs

F0：With ADC_CLK = 14 MHz and a sampling time of 1.5 ADC clock cycles:

Tconv = 1.5 + 12.5 = 14 ADC clock cycles = 1 µs

5.  外设资源更丰富，增加了AES加密单元、普通定时器单元、硬件随机数RNG单元、DMA多路复用请求仲裁单元，可编程映射DMA请求，好处是使DMA通道对应的外设更加灵活，不再受限、低功耗串口等，更加安全高效。当然相比之下也有牺牲，比如说全速USB2.0，串口数量、CAN等。

三：我们从系统架构上来瞧瞧看：

1. F0的AHB2总线消失了，引入了新的IOPORT总线，STM32F0的GPIO Ports由总线矩阵通过AHB2总线访问，STM32G0的GPIO Ports直接挂在IOPORT总线上，CPU可直接访问，速度更快！

2. STM32F0的外部中断EXIT模块由总线矩阵通过AHB1总线->（AHB->APB桥）来访问，STM32G0的外部中断EXIT模块由总线矩阵通过AHB1总线直接访问，速度更快！

四：从时钟来看：

由于内核使用区别，两款芯片的RCC时钟也略有区别，如上图所示，主要体现在内部的时钟资源及频率差异，最大主频差异以及复位后的系统时钟频率差异。

五：从电源供电来看

供电电压范围更宽，G0:1.6V-3.6V    F0:1.8V-3.6V，相比之下G0的低功耗睡眠模式更加出色。

六：最后跟大家看一下M0和M0+内核的区别

除了上面展示的内容之外，还有部分区别未展示，比如说中断向量表的内容有改变，G0支持向量表位置重定义、低功耗改善等等、其中不得不提到一点相比F0，G0增加了内部外设的互联功能，通过配置外设中间可直接互联，可以减小CPU额外开销！

C语言中的动态内存-----栈内存

C语言程序的动态内存分为栈内存区域和堆内存区域两种。栈内存是由编译器管理的，而堆内存是由程序调用具体的库函数管理的。我们今天分析下栈内存的概念。

栈内存的使用在很大程度上依赖于处理器的硬件机制。在处理器中，一般有一个寄存器来表示当前栈指针的位置，通常在内存中分配一块区域，这块内存的上界（高内存地址）和下界（低内存地址）之间是可用的栈内存区域。

栈指针是一个指向栈区域内部的指针，也就是它的值是一个地址，这个地址位于栈区的下界和栈区的上界之间。栈指针把这个栈区域分为两个部分，一个是已经使用的区域，一个是没有使用的区域。

对于栈内存的增长方向有两种：一种是向上增长的，也就是低地址向高地址增长；另一个是向下增长的，高地址向低地址增长。在目前常见的体系结构和编译系统中，栈大多是向下增长的，我们也是看下这种常见的增长形式。在初始阶段，栈指针是指向栈区间的上界。随着栈使用量的增加，栈指针的值将向低地址移动，也就是在变小。

栈内存在使用过程中有一个重要的特性是先入后出，也就是后入栈的内容将先出栈，而先入栈的后出栈。类似于一个口的瓶子，先进去的在底下，要想底下的出来就先把上面的先倒出来。栈内存的使用情况见下图：

入栈的过程和出栈的过程我们安全用图形来表示，更形象些吧~

在入栈的过程中，如果栈指针的变化超出栈内存的区域，将发生栈溢出。

从图中看出栈指针的功能是标识当前的栈位置。对栈内存处理中，每次能够获取的内容都是最后可放入栈内存的内容，而每次放入栈内存中的内容都将位于栈区域的最后。

总的来说其实栈是一个先入后出的内存区域，栈指针是提供一种硬件的内存机制。

还有一个大家可能都没听说过，或者都没关注过的，我们来一起了解一下，就是满栈和空栈的概念，我们还是通过图来形容一下，这个是由处理器的体系结构决定的。与程序的编写没有关系，甚至编译器都不需要关注这个问题。无论在哪种情况下，栈指针都是已经使用的栈区域和未使用的栈区域的分界线。

在满栈的情况：栈指针当前的位置是已经使用的栈区域。

在空栈的情况：栈指针当期的位置是没有使用的栈区域。

这个仅供大家了解下就可以了，毕竟对于我们大多数人来说都是应用者，多了解点底层的总没错，但也不必太深挖。对于栈内存的概念我就分享到这里，其实这个对于写汇编的人来说就很有用处了，或者去多读一些汇编就很能清楚栈内存的妙用了。后续我分享堆内存的一些概念，话说知识是一点点积累的过程，有时候觉得前面有的知识点懵懵懂懂的突然连起来就又通透了。这就是坚持学习的作用，希望大家都能坚持多学，才能更会用。

堆内存的那些事

上一篇我们分享了栈内存的概念，现在我们分享下堆内存的概念。

在一般的编译系统中，堆内存的分配方向和栈内存是相反的。当栈内存从高地址向低地址增长的时候，堆内存从低地址向高地址分配。

在C语言中，堆内存在分配和释放的时候，是程序通过调用C语言的库函数完成的。这和栈内存的分配有区别，栈内存利用的是处理器的硬件机制，而堆内存的处理使用的是库函数。

我们来看下堆内存的分配情况：

在堆内存的分配过程中，每次分配将返回一个当前分配地址的指针。在程序中如果多次分配内存，可以得到多个内存指针，每个内存指针都是本次分配内存的地址。在释放内存的时候，只需要对每个指针进行操作，那个指针所指向的内存就会被释放，而对其他的内存区域没有影响。

从内存的分配和使用上，可以看出栈内存和堆内存的区别：栈内存只有一个入口点，就是栈指针，栈内存压入和弹出的时候栈指针将发生变化，栈指针标识当前栈区域中已使用和未使用的界限，程序在访问栈内存的时候都只能通过栈指针及其偏移量；而堆内存有多个入口点，每次分配得到的指针是访问内存的入口，每个分配内存区域都可以被单独释放，程序对堆内存可以通过每次分配得到的指针访问。

堆内存有一个整体分配的过程，按照向上的堆内存分配方向。随着堆内存使用量的增加，堆内存将逐渐向高地址分配。这只是一个大体的增长的方面，在堆内存中，已使用的区域和未使用的区域是交错的，而不是像栈区域那样有明显的分界线。

堆内存的释放看下面这个图：

看到这样频繁的使用区域和释放，那么很容易看出堆内存是不连续的，跟堆内存的使用方式有关系，这个分配就相对自由灵活了，但是也是会在低地址向高地址发展的方向分配的。

比如上面释放后再分配就可以是下面两种情况：

先看再次分配1的情况：当新分配的需求比中间（刚刚释放）区域小，那么就会在紧接着的区域给分配。

再看再次分配2的情况：当新分配的需求比中间（释放的）区域大，那么只能往后寻求能给的区域。

当频繁的分配和释放内存的过程中，会很容易出现在两块已经分配的内存之间较小的未分配内存区域，这些其实可以用，但是由于他们的空间比较小，不够连续内存的分配，所以分配的时候就很难再次使用，这些较小的内存就是我们常说的内存碎片。

我们再来聊一下在C程序中堆空间的使用。

在C语言中，堆内存区域的分配和释放是通过调用库函数来完成的，实现的函数主要有四个：

void *malloc(size_t size);    //分配内存空间

void free(void *ptr);     //释放内存空间

void *calloc(size_t nmemb,size_t size);  //分配内存空间

void *realloc(void * ptr,size_t size);  //重新分配内存空间

注意：使用上面这几个函数需要包含标准库文件 <stdlib.h>

那么库函数怎么使用呢，内存分配了就要有释放，那么常用的就是malloc()和free()两个函数。malloc()函数的输入是需要分配内存的大小，输出是分配内存的指针。如果分配不成功，则返回NULL。

free()函数的输入是需要释放的指针，可以接受任何形式的指针。这个指针必须是由分配函数分配出来的。

例如：

int *pa;

pa = (int *)malloc(sizeof(int));//分配一个int大小的指针

if(NULL != pa)

{

free(pa);

}

内存使用完成需要释放，以便分配给其他程序使用。

calloc()也是内存分配的，只是可以把分配好的内存区域的初始值全部设置为0。还有这个分配内存有两个参数，第一个是分配单元的大小，第二个是要分配的数目。

malloc(sizeof(unsigned int)*10);   ==     calloc(sizeof(unsigned int),10)

realloc()有两个参数，一个是指向内存的地址指针，一个是要重分配内存的大小，返回值是指向所分配内存的指针。

1、当参数指针为NULL的时候，作为malloc使用，分配内存

2、当重分配内存大小为0的时候，作为free使用，释放内存

3、当指针和重分配内存大小均不为0的时候，根据指针指向的堆内存区域的情况和指针大小重新分配内存。

对于realloc()作为重新分配内存的时候，有三种可能出现：

1、缩小内存

2、扩大内存，不需要移动指针

3、扩大内存，需要移动指针（指定内存区域大小不够）

在堆内存的管理上，主要容易出现以下几个问题：

1、开辟的内存没有释放，造成内存泄漏（系统不会释放任何用户分配的内存）

2、野指针被使用或释放（内存释放后，需要将内存指针置为NULL）

3、非法释放指针（分配了有效内存才存在释放，否则是非法的）

在C语言语法的方面对栈内存和堆内存如何使用没有限制。然后从使用的角度，栈内存更适用于容量较小的单个变量（例如：C语言的基本变量类型、较小的结构体和数组），堆内存则适用于开辟较大块的内存。栈内存由编译器分配和释放，堆内存由程序员分配和释放。

USB与TTL通信之默契轨道---技术剖析（二）

前情提要：前面一篇说了我设计这个全隔离小模块的想法和原理图设计，那么接下来就说下我的PCB设计过程，有些需要注意的点，我经历的坎坷分享给大家，希望能有些值得借鉴的地方。

对于PCB设计，虽然我设计的是个小模块，然而不能因为产品小就大意，每个产品都有它的特点，都有需要注意的地方，经验积累都是一点一滴开始的。

首先是左进右出原则，左边是USB端口，右边是TTL端口。（当然这个根据个人喜好，我的原则就是接口在板边）

导入后布局前首先就是设置规则，有了规则约束布局走线自然也顺畅些了，没规矩不成方圆。

继续简单看下我的常规规则设置，

1、间距的设置，常规间距我是配置0.2，敷铜间距0.5；根据实际需求设定。

2、线宽的范围放大，推荐的一般我不会改变。

3、孔径的大小我一般会把范围设置大点，个人调节不受约束。

4、一些间距的设置一般我都会设置为0，布局以及走线靠个人把控，比如孔到孔的间距，最小阻焊的间距，丝印到阻焊的间距，丝印到丝印的间距等。这个都可以根据自己需要设置。

规则设置好就开始布局了，布局过程遵循规则就可以了。

因为全隔离，有隔离芯片加隔离电源，隔离的要分开，考虑敷铜的方便，所以在布局的时候把模块要摆放好。

布局模块化先把位置放置好，USB端口已经说过了，接着看下转化芯片的放置，直接上图看下吧。

接下来看下隔离部分的布局，前面说了因为全隔离，通过敷铜共地，然后就要考虑隔离部分器件的摆放。

布局的过程也就对走线也考虑了，那么在走线的时候就可以顺利很多了。当然会有小的调整。

大体就是这样的。

走线主要注意的是线宽，常规都是推荐线宽就可以了，电源和地的部分还是需要宽一些，一般我用0.4mm。再有需要注意的一点是最后需要加泪滴效果，为了避免焊接线容易断。

还有敷铜后需要加一些过孔，为了铜皮的电位平等。这些都是需要注意的点。丝印的调整，以及一些版本号，日期号的添加，这些都是很有必要的。

这里分享下我的最终实现效果：

到这里，这个全隔离小模块就实现了，其实并不难，后面就是打板事宜了，感兴趣的可以试着实现一下，真正的实践才是真的成长，后面我还会陆续分享我的视频实现过程，那是整个过程走了一遍，希望能给到大家一些值得借鉴的东西，还希望大家能多跟我交流和沟通。我陆续分享乌云踏雪系列的转换模块的实现过程，有视频，有文章，这个是乌云踏雪系列的C1A（Connect），后面会实现更多。有兴趣的就持续关注下哈，如果有想实现的点子也可以跟我们交流，一起实现哈。

常见的内存错误及对策

对于用C或C++除了考虑上层应用，还需要考虑底层的内存管理，或者说内存泄漏的问题。

1、指针没有指向一块合法的内存

定义了指针变量，但是没有为指针分配内存，即指针没有指向一块合法的内存。

①结构体成员指针未初始化

定义一个结构体变量，但是结构体内部定义了指针成员，往往应用结构体变量的时候如果不给这 个成员指向一个合法的地址只是给成员分配了字节数，应用的时候对应内存的区域指针成员是无权 访问的，所以需要对结构体分配内存，结构体成员中指针变量也要分配内存，否则访问不到有效地 址。

②没有为结构体指针分配足够的内存

分配内存的时候，分配的内存大小不合适，比如开辟内存空间时sizeof(struct stu)误写为sizeof(struct stu *)，书写错误会导致开辟空间不正确。

③函数的入口校验

不管什么时候，我们使用指针之前一定要确保指针是有效的。一般在函数入口处使用         assert （NULL !=p）对参数进行校验。在非参数的地方使用if(NULL != p)来校验。但这都有一个要求，也就 是p在定义的同时被初始化为NULL，如果没有被初始化为NULL，那么校验也起不了作用，没有被 初始化的指针变量，内部是一个非NULL的乱码

assert是一个宏，而不是函数，包含在assert.h头文件中。如果其后面括号里的值为假，则程序终 止运行，并提示出错；如果后面括号里的值为真，则继续运行后面的代码。

2、为指针分配的内存太小或内存访问越界

为指针分配了内存，但是内存大小不够，导致出现越界错误。

通常这种问题都会出现在我们容易忽略的字符串常量中，往往会忘记结束标志“”，在开辟内存的时候sizeof计算中需要把结束标志加上，还有计算分配空间大小的时候最好用sizeof来操作，移植性也好。

再有内存分配成功，且已经初始化，但是操作越过了内存的边界。

这种错误经常是由于操作数组或者指针时出现“多1”或“少1”而出现的。比如：

for（int i = 0; i < = 10;i++）

一般for循环的循环变量一定要使用半开半闭的区间，而且如果不是特殊情况，循环变量尽量从0开始。

3、内存泄漏

内存泄漏几乎是很难避免的，不管是老手还是新手，都存在这个问题。甚至包括Windows、Linux这类软件，都或多或少有内存泄漏。也许对于一般的应用软件来说，这个问题似乎不是那么突出，重启一下也不会造成太大损失。但是如果你开发的是嵌入式系统软件，比如汽车制动系统、心跳起搏器等对安全要求非常高的系统，你总不能让心脏起搏器重启吧。

会产生内存泄漏的内存就是堆上的内存，也就是由malloc系列函数或new操作符分配的内存。如果用完没有及时free或delete，这块内存就无法释放，直到整个程序终止。

malloc是一个函数，专门用来从堆上分配内存，malloc函数的返回值是一个void类型的指针，参数是申请分配的内存大小，内存分配成功后，malloc函数返回这块内存的首地址，需要一个指针来接收这个地址，那么申请了就能成功吗？不一定的，如果所申请的内存块大于目前堆上剩余内存块，则内存分配失败，函数返回NULL。我们需要知道内存申请分配是连续的一块内存，如果剩余内存不够返回就是空，那么我们可以用校验的方式（if(NULL != p)）来验证是否分配成功。当然也可以申请0字节内存，返回不是NULL，是一个正常的内存地址，但是你却无法使用这块大小为0的内存，这就好比尺子上的某个刻度，刻度本身并没有长度，只有某两个刻度一起才能量出长度。

再来说下内存释放，既然有分配，就有释放，不然的话，有限的内存总会用光，而没有释放的内存却在空闲。与malloc对应的就是free函数了。free函数只有一个参数，就是所要释放的内存块的首地址，比如：free(p);这个函数主要是让指针变量和这块内存脱离关系，从此这个指针变量和分配过的这快内存没有关系了，那么指针变量p本身保存的地址并没有改变，但是它对这个地址处的那块内存却已经没有所有权了。释放后，那块内存里面保存的值并没有改变，只是再也没有办法使用了。

需要记住一点malloc和free是匹配使用的，如果多写两次malloc或者free都会出错。

再有内存释放之后需要给指针变量赋值为NULL，如果没有把指针置NULL，这个指针就成为了野指针，这是很危险的，也是经常出错的地方。

4、内存已经被释放了，但是继续通过指针来使用

一般会有以下三种情况：

①就是上面所说的，free(p)之后，继续通过p指针来访问内存，解决的办法就是给P指NULL。

②函数返回栈内存，这是初学者最容易犯的错误。比如在函数内部定义了一个数组，却用return 语句返回指向该数组的指针。解决的办法就是弄明白栈上变量的声明周期。

③内存使用太复杂，弄不清到底哪块内存被释放，哪块没有释放。解决的办法是重新设计程序，改善对象之间的调用关系。

写程序就是要多练习，多调试代码，同时多总结经验，少走弯路。共勉。