不少初学者都有这么一个疑问：

• 8位单片机定义一个 int 型变量，占几个字节？

• 32位单片机定义一个 char 型变量，占几个字节？
  

有很多人工作几年的工程师都不知道具体占多少字节，其实通过手动验证一下就知道了。

今天结合Keil C51（AT89C51），以及Keil MDK（STM32）为大家验证一下 char、short、int、float、double 到底占几字节空间。

Keil C51、8位单片机

这一节基于Keil C51工具，8位单片机（AT89C51）进行测试。

//char a;

void main(void)
{  
    while(1)  {  }
}

这是一个很简单的Demo，只针对变量占用空间大小进行测试，主要是对比 data 的大小，初始值为9。(其中系统【启动文件】占用了9字节RAM空间）

1.char占1字节

定义变量：

char a;

编译结果：

Program Size: data=10.0 xdata=0 code=17

2.short占2字节

定义变量：

short a;

编译结果：

Program Size: data=11.0 xdata=0 code=17

3.int占2字节

定义变量：

int a;

编译结果：

Program Size: data=11.0 xdata=0 code=17

4.float占4字节

定义变量：

float a

编译结果：

Program Size: data=13.0 xdata=0 code=17

5.double占4字节

定义变量：

double

编译结果：

Program Size: data=13.0 xdata=0 code=17

Keil MDK、32位单片机

这一节基于Keil MDK工具，32位单片机（STM32）进行测试。

//char a;

int main(void)
{  
    while(1)  
    {
        //    a++;  
    }
}

这也是一个很简单的Demo，主要是对比 RW-data 的大小，初始值为0。（其中 ZI-data=1024 为系统分配的栈空间大小）
1.char占1字节

定义变量：

char a;

编译结果：

Program Size: Code=512 RO-data=436 RW-data=4 ZI-data=1028

啥？占了4个字节？

答案：只占了一个字节，因为32位机是4字节为一个“单元”，一个 char 只占用了其中1字节（类似结构体占用空间大小，这里还牵涉到大小端对齐模式）。

再举一个例子：定义4个 char 型变量，还是占用4字节空间（short原理一样）。

再次提示：

注意4字节为一个“单元”，超过这个单元就分配到“下一个单元”，比如：

char a;
int b;
char c;

这里就会占用12（3 * 4）字节空间（a、b、c各自占4字节）。

2.short占2字节

定义变量：

short a;

编译结果：

Program Size: Code=512 RO-data=436 RW-data=4 ZI-data=1028

这里和 char 类似，如果定义两个 short 也是占用4个字节。

3.int占4字节

定义变量：

int a;

编译结果：

Program Size: Code=512 RO-data=436 RW-data=4 ZI-data=1028

32位机，int占用4字节没什么说的。

4.float占4字节

定义变量：

float a;

编译结果：

Program Size: Code=520 RO-data=436 RW-data=4 ZI-data=1028

5.double占8字节

定义变量：

double a;

编译结果：

Program Size: Code=1156 RO-data=436 RW-data=8 ZI-data=1024

总结

上面验证情况在Keil C51、 8位单片机（AT89C51）中：

• char：占1字节

• short、int：占2字节

• float、double：占4字节

在Keil MDK、 32位单片机（STM32）中：

• char：占1字节

• short：占2字节

• int、float：占4字节

• double：占8字节
  

通过对比上面几个变量，以及编译结果，得出一些结论。

1.变量占多少字节，与处理器（以及编译器）有关；

2.浮点数运算更占代码空间，且double比float更占空间。

上面基于32位机中进行了 a++； 运算，明显float、double打码量（code）更大。

3.变量数据对齐规则和结构体一样。

经典的面试题：计算下面结构体占用多少字节?

struct Str
{  
    char a;  
    short b;  
    int c;  
    char d;
};

这里面还有很多细节内容，可能很多人都没有深入研究过，感兴趣的朋友可以自己实验研究一下。

算法（Algorithm）：计算机解题的基本思想方法和步骤。

算法的描述：是对要解决一个问题或要完成一项任务所采取的方法和步骤的描述，包括需要什么数据（输入什么数据、输出什么结果）、采用什么结构、使用什么语句以及如何安排这些语句等。通常使用自然语言、结构化流程图、伪代码等来描述算法。

一、计数、求和、求阶乘等简单算法 

此类问题都要使用循环，要注意根据问题确定循环变量的初值、终值或结束条件，更要注意用来表示计数、和、阶乘的变量的初值。

例：用随机函数产生100个[0，99]范围内的随机整数，统计个位上的数字分别为1，2，3，4，5，6，7，8，9，0的数的个数并打印出来。

本题使用数组来处理，用数组a[100]存放产生的确100个随机整数，数组x[10]来存放个位上的数字分别为1，2，3，4，5，6，7，8，9，0的数的个数。即个位是1的个数存放在x[1]中，个位是2的个数存放在x[2]中，……个位是0的个数存放在x[10]。

void main()
{
    int a[101],x[11],i,p;
    for(i=0;i<=11;i++)x=0;
    for(i=1;i<=100;i++)
    {
        a=rand() % 100;
        printf("%4d",a);
        if(i%10==0)printf("\n");
    }
    for(i=1;i<=100;i++)
    {
        p="a"%10;
        if(p==0) p="10";
        x[p]=x[p]+1;
    }
    for(i=1;i<=10;i++)
    {
        p="i";
        if(i==10) p="0";
        printf("%d,%d\n",p,x);
    }
    printf("\n");
}

二、求两个整数的最大公约数、最小公倍数

分析：求最大公约数的算法思想：(最小公倍数=两个整数之积/最大公约数)

(1) 对于已知两数m，n，使得m>n；

(2) m除以n得余数r；

(3) 若r=0，则n为求得的最大公约数，算法结束；否则执行(4)；

(4) m←n，n←r，再重复执行(2)。

例如: 求 m="14" ,n=6 的最大公约数.

m n r

14 6 2

6 2 0

void main()
{ 
    int nm,r,n,m,t;
    printf("please input two numbers:\n");
    scanf("%d,%d",&m,&n);
    nm=n*m;
    if (m
    { 
        t="n"; n="m"; m="t"; 
    }
    r=m%n;
    while (r!=0)
    { 
        m="n"; n="r"; r="m"%n; 
    }
    printf("最大公约数:%d\n",n);
    printf("最小公倍数:%d\n",nm/n);
}

三、判断素数

只能被1或本身整除的数称为素数 基本思想：把m作为被除数，将2—INT（ ）作为除数，如果都除不尽，m就是素数，否则就不是。（可用以下程序段实现）

void main()
{ 
    int m,i,k;
    printf("please input a number:\n");
    scanf("%d",&m);
    k=sqrt(m);
    for(i=2;iif(m%i==0) break;
    if(i>=k)printf("该数是素数");
    elseprintf("该数不是素数");
}

将其写成一函数,若为素数返回1，不是则返回0

int prime( m%)
{
    int i,k;
    k=sqrt(m);
    for(i=2;i
    if(m%i==0) return 0;
    return 1;
}

四、验证哥德巴赫猜想 

（任意一个大于等于6的偶数都可以分解为两个素数之和）

基本思想：n为大于等于6的任一偶数，可分解为n1和n2两个数，分别检查n1和n2是否为素数，如都是，则为一组解。如n1不是素数，就不必再检查n2是否素数。先从n1=3开始，检验n1和n2（n2=N-n1）是否素数。然后使n1+2 再检验n1、n2是否素数，… 直到n1=n/2为止。

利用上面的prime函数，验证哥德巴赫猜想的程序代码如下：

#include "math.h"
int prime(int m)
{ 
    int i,k;
    k=sqrt(m);
    for(i=2;i
    if(m%i==0) break;
    if(i>=k)
    return 1;
    elsereturn 0;
}
main()
{ 
    int x,i;
    printf("please input a even number(>=6):\n");
    scanf("%d",&x);
    if (x<6||x%2!=0)
    printf("data error!\n");
    else
    for(i=2;i<=x/2;i++)
    if (prime(i)&&prime(x-i))
    {
        printf("%d+%d\n",i,x-i);
        printf("验证成功!");
        break;
    }
}

五、排序问题

1．选择法排序（升序）

基本思想：

1）对有n个数的序列（存放在数组a(n)中），从中选出最小的数，与第1个数交换位置；

2）除第1 个数外，其余n-1个数中选最小的数，与第2个数交换位置；

3）依次类推，选择了n-1次后，这个数列已按升序排列。

程序代码如下：

void main()
{ 
    int i,j,imin,s,a[10];
    printf("\n input 10 numbers:\n");
    for(i=0;i<10;i++)
    scanf("%d",&a);
    for(i=0;i<9;i++)
    { 
        imin="i";
        for(j=i+1;j<10;j++)
        if(a[imin]>a[j]) imin="j";
        if(i!=imin)
        {
            s=a; a=a[imin]; a[imin]=s; 
        }
        printf("%d\n",a);
    }
}

2．冒泡法排序（升序）

基本思想：(将相邻两个数比较，小的调到前头)

1）有n个数（存放在数组a(n)中），第一趟将每相邻两个数比较，小的调到前头，经n-1次两两相邻比较后，最大的数已“沉底”，放在最后一个位置，小数上升“浮起”；

2）第二趟对余下的n-1个数（最大的数已“沉底”）按上法比较，经n-2次两两相邻比较后得次大的数；

3）依次类推，n个数共进行n-1趟比较，在第j趟中要进行n-j次两两比较。

程序段如下

void main()
{ 
    int a[10];
    int i,j,t;
    printf("input 10 numbers\n");
    for(i=0;i<10;i++)
    scanf("%d",&a);
    printf("\n");
    for(j=0;j<=8;j++)
    for(i=0;i<9-j;i++)
    if(a>a[i+1])
    {
        t=a;a=a[i+1];
        a[i+1]=t;
    }
    printf("the sorted numbers:\n");
    for(i=0;i<10;i++)
    printf("%d\n",a);
}

3．合并法排序（将两个有序数组A、B合并成另一个有序的数组C，升序） 

基本思想：

1）先在A、B数组中各取第一个元素进行比较，将小的元素放入C数组；

2）取小的元素所在数组的下一个元素与另一数组中上次比较后较大的元素比较，重复上述比较过程，直到某个数组被先排完；

3）将另一个数组剩余元素抄入C数组，合并排序完成。

程序段如下：

void main()
{ 
    int a[10],b[10],c[20],i,ia,ib,ic;
    printf("please input the first array:\n");
    for(i=0;i<10;i++)
    scanf("%d",&a);
    for(i=0;i<10;i++)
    scanf("%d",&b);
    printf("\n");
    ia=0;ib=0;ic=0;
    while(ia<10&&ib<10)
    { 
        if(a[ia]
        { 
            c[ic]=a[ia];ia++;
        }
        else
        { 
            c[ic]=b[ib];ib++;
        }
        ic++;
    }
    while(ia<=9)
    { 
        c[ic]=a[ia];
        ia++;ic++;
    }
    while(ib<=9)
    { 
        c[ic]=b[ib];
        b++;ic++;
    }
    for(i=0;i<20;i++)
    printf("%d\n",c);
}

六、查找问题 

① 顺序查找法（在一列数中查找某数x） 

基本思想：一列数放在数组a[1]---a[n]中，待查找的数放在x 中，把x与a数组中的元素从头到尾一一进行比较查找。用变量p表示a数组元素下标，p初值为1，使x与a[p]比较，如果x不等于a[p]，则使p=p+1，不断重复这个过程；一旦x等于a[p]则退出循环；另外，如果p大于数组长度，循环也应该停止。（这个过程可由下语句实现）

void main()
{ 
    int a[10],p,x,i;
    printf("please input the array:\n");
    for(i=0;i<10;i++)
    scanf("%d",&a);
    printf("please input the number you want find:\n");
    scanf("%d",&x);
    printf("\n");
    p=0;
    while(x!=a[p]&&p<10)
    p++;
    if(p>=10)
    printf("the number is not found!\n");
    else
    printf("the number is found the no%d!\n",p);
}

思考：将上面程序改写一查找函数Find，若找到则返回下标值，找不到返回-1

② 基本思想：一列数放在数组a[1]---a[n]中，待查找的关键值为key，把key与a数组中的元素从头到尾一一进行比较查找，若相同，查找成功，若找不到，则查找失败。(查找子过程如下。index：存放找到元素的下标。)

void main()
{ 
    int a[10],index,x,i;
    printf("please input the array:\n");
    for(i=0;i<10;i++)
    scanf("%d",&a);
    printf("please input the number you want find:\n");
    scanf("%d",&x);
    printf("\n");
    index=-1;
    for(i=0;i<10;i++)
    if(x==a)
    { 
        index="i"; break;
    }
    if(index==-1)
    printf("the number is not found!\n");
    else
    printf("the number is found the no%d!\n",index);
}

七、二分法

在一个数组中，知道一个数值，想确定他在数组中的位置下标，如数组：A[5] = {1，2，6，7，9};我知道其中的值为6，那么他的下标位置就是3。

int Dichotomy(int *ucData, int long, int num)
{
    int iDataLow  = 0 ;
    int iDataHigh = num - 1;
    int iDataMIDDLE;
    while (iDataLow <= iDataHigh)
    {
        iDataMIDDLE = (iDataHigh + iDataLow)/2;
        if (ucData[iDataMIDDLE] > long)
        {
            iDataHigh = iDataMIDDLE - 1 ;
        }
        else if (ucData[iDataMIDDLE] < long)
        {
            iDataLow = iDataMIDDLE + 1 ;
        }  
        else
        {
            return iDataMIDDLE ;
        }
    }
}

八、限幅滤波法

对于随机干扰 , 限幅滤波是一种有效的方法；

基本方法：比较相邻n 和 n - 1时刻的两个采样值y(n)和 y(n – 1)，根据经验确定两次采样允许的最大偏差。如果两次采样值的差值超过最大偏差范围 ,认为发生可随机干扰 ,并认为后一次采样值y(n)为非法值 ,应予删除 ,删除y(n)后 ,可用y(n – 1) 代替y(n)；若未超过所允许的最大偏差范围 ,则认为本次采样值有效。

下面是限幅滤波程序：( A 值可根据实际情况调整，value 为有效值 ,new_value 为当前采样值滤波程序返回有效的实际值 )

#define A 10char value;
char filter()
{   
    char new_value;
    new_value = get_ad();
    if ( ( new_value - value > A ) || ( value - new_value > A ))  return value;
    return new_value;
}

九、中位值滤波法

中位值滤波法能有效克服偶然因素引起的波动或采样不稳定引起的误码等脉冲干扰；

对温度 液位等缓慢变化的被测参数用此法能收到良好的滤波效果 ,但是对于流量压力等快速变化的参数一般不宜采用中位值滤波法；

基本方法：对某一被测参数连续采样 n次(一般 n 取奇数) ,然后再把采样值按大小排列 ,取中间值为本次采样值。

下面是中位值滤波程序：

#define N   11
char filter()
{  
    char value_buf[N]， count,i,j,temp;
    for ( count=0;count
    {  
        value_buf[count] = get_ad();    delay();   
    }
    for (j=0;j
    {  
        for (i=0;i
        {  
            if ( value_buf>value_buf[i+1] )
            {
                temp = value_buf;
                value_buf = value_buf[i+1];
                value_buf[i+1] = temp;  
            }
        }
    }
    return value_buf[(N-1)/2];
}

十.算术平均滤波法

算术平均滤波法适用于对一般的具有随机干扰的信号进行滤波。这种信号的特点是信号本身在某一数值范围附近上下波动 ,如测量流量、 液位；

基本方法：按输入的N 个采样数据 ,寻找这样一个 Y ,使得 Y 与各个采样值之间的偏差的平方和最小。

编写算术平均滤波法程序时严格注意:

一.为了加快数据测量的速度 ,可采用先测量数据 存放在存储器中 ,测完 N 点后 ,再对 N 个数据进行平均值计算;

二.选取适当的数据格式 ,也就是说采用定点数还是采用浮点数。其程序如下所示：

#define N 12
char filter()
{
    int   sum = 0，count;
    for ( count=0;count
    {  
        sum+=get_ad();    
        delay();
    }
    return (char)(sum/N);
}

十一、递推平均滤波法

基本方法：采用队列作为测量数据存储器 ,   设队列的长度为 N ,每进行一次测量 ,把测量结果放于队尾 ,而扔掉原来队首的一个数据 ,这样在队列中始终就有 N 个 “最新” 的数据。当计算平均值时 ,只要把队列中的 N 个数据进行算数平均 ,就可得到新的算数平均值。这样每进行一次测量 ,就可得到一个新的算术平均值。

#define N 12
char value_buf[N]，i=0;
char filter()
{ 
    char count; 
    int   sum=0;
    value_buf[i++] = get_ad();
    if ( i == N )    i = 0;
    for ( count=0;count
    sum = value_buf[count];
    return (char)(sum/N);
}

十二、一阶滞后滤波法

优点：对周期性干扰具有良好的抑制作用,适用于波动频率较高的场合；

缺点：相位滞后，灵敏度低.滞后程度取决于a值大小.不能消除滤波频率高于采样频率的1/2的干扰信号。程序如下：

#define a 50
char value;
char filter()
{ 
    char   new_value;
    new_value = get_ad();
    return (100-a)*value + a*new_value;
}

十三、PID控制算法

在过程控制中，按偏差的比例（P）、积分（I）和微分（D）进行控制的PID控制器（亦称PID调节器）是应用最为广泛的一种自动控制器;

对于过程控制的典型对象──“一阶滞后＋纯滞后”与“二阶滞后＋纯滞后”的控制对象，PID控制器是一种最优控制;

PID调节规律是连续系统动态品质校正的一种有效方法，它的参数整定方式简便，结构改变灵活（PI、PD、…）。

一  模拟PID调节器

PID调节器各校正环节的作用：

比例环节：即时成比例地反应控制系统的偏差信号e(t)，偏差一旦产生，调节器立即产生控制作用以减小偏差；

积分环节：主要用于消除静差，提高系统的无差度。积分时间常数TI越大，积分作用越弱，反之则越强；

微分环节：能反应偏差信号的变化趋势(变化速率)，并能在偏差信号的值变得太大之前，在系统中引入一个有效的早期修正信号，从而加快系统的动作速度，减小调节时间。

PID调节器是一种线性调节器，它将给定值r(t)与实际输出值c(t)的偏差的比例(P)、积分(I)、微分(D)通过线性组合构成控制量，对控制对象进行控制。

程序片段如下：

#include
#include
typedef struct PID 
{
    double SetPoint;     // 设定目标Desired value
    double Proportion;    // 比例常数Proportional Const
    double Integral;      // 积分常数Integral Const
    double Derivative;    // 微分常数Derivative Const
    double LastError;    // Error[-1]
    double PrevError;    // Error[-2]
    double SumError;   // Sums of Errors
} PID;

主程序：

double sensor (void)
{
    return 100.0; 
}
void actuator(double rDelta)
{}
void main(void)
{
    PID sPID;
    double rOut;
    double rIn;
    PIDInit ( &sPID );
    sPID.Proportion = 0.5；
    sPID.Derivative = 0.0;
    sPID.SetPoint = 100.0;
    for (;;) 
    {
        rIn = sensor ();
        rOut = PIDCalc ( &sPID,rIn );
        actuator ( rOut );
    }
}

十四、开根号算法

单片机开平方的快速算法

因为工作的需要，要在单片机上实现开根号的操作。目前开平方的方法大部分是用牛顿迭代法。我在查了一些资料以后找到了一个比牛顿迭代法更加快速的方法。不敢独享，介绍给大家，希望会有些帮助。

1.原理

因为排版的原因，用pow(X,Y)表示X的Y次幂，用B[0]，B[1]，...，B[m-1]表示一个序列，其中[x]为下标。

假设：B[x],b[x]都是二进制序列,取值0或1。M = B[m-1]*pow(2,m-1) + B[m-2]*pow(2,m-2) + ... + B[1]*pow(2,1) + B[0]*pow(2,0)N = b[n-1]*pow(2,n-1) + b[n-2]*pow(2,n-2) + ... + b[1]*pow(2,1) + n[0]*pow(2,0)pow(N,2) = M

(1) N的最高位b[n-1]可以根据M的最高位B[m-1]直接求得。

设 m 已知,因为 pow(2, m-1) <= M <= pow(2, m)，所以 pow(2, (m-1)/2) <= N <= pow(2, m/2)

如果 m 是奇数，设m=2*k+1,

那么 pow(2,k) <= N < pow(2, 1/2+k) < pow(2, k+1),

n-1=k, n=k+1=(m+1)/2

如果 m 是偶数，设m=2k,

那么 pow(2,k) > N >= pow(2, k-1/2) > pow(2, k-1),

n-1=k-1,n=k=m/2

所以b[n-1]完全由B[m-1]决定。

余数 M[1] = M - b[n-1]*pow(2, 2*n-2)

(2) N的次高位b[n-2]可以采用试探法来确定。因为b[n-1]=1，假设b[n-2]=1，则 pow(b[n-1]*pow(2,n-1) + b[n-1]*pow(2,n-2), 2) = b[n-1]*pow(2,2*n-2) + (b[n-1]*pow(2,2*n-2) + b[n-2]*pow(2,2*n-4)),

然后比较余数M[1]是否大于等于 (pow(2,2)*b[n-1] + b[n-2]) * pow(2,2*n-4)。这种比较只须根据B[m-1]、B[m-2]、...、B[2*n-4]便可做出判断，其余低位不做比较。

若 M[1] >= (pow(2,2)*b[n-1] + b[n-2]) * pow(2,2*n-4), 则假设有效，b[n-2] = 1；

余数 M[2] = M[1] - pow(pow(2,n-1)*b[n-1] + pow(2,n-2)*b[n-2], 2) = M[1] - (pow(2,2)+1)*pow(2,2*n-4)；

若 M[1] < (pow(2,2)*b[n-1] + b[n-2]) * pow(2,2*n-4), 则假设无效，b[n-2] = 0；余数 M[2] = M[1]。

(3) 同理，可以从高位到低位逐位求出M的平方根N的各位。

使用这种算法计算32位数的平方根时最多只须比较16次，而且每次比较时不必把M的各位逐一比较，尤其是开始时比较的位数很少，所以消耗的时间远低于牛顿迭代法。

3. 实现代码

这里给出实现32位无符号整数开方得到16位无符号整数的C语言代码。

/****************************************/
/*Function: 开根号处理                  */
/*入口参数：被开方数，长整型            */
/*出口参数：开方结果，整型              */
/****************************************/
unsigned int sqrt_16(unsigned long M)
{
    unsigned int N, i;
    unsigned long tmp, ttp;   // 结果、循环计数
    if (M == 0)               // 被开方数，开方结果也为0
    return 0;
    N = 0;
    tmp = (M >> 30);          // 获取最高位：B[m-1]
    M <<= 2;
    if (tmp > 1)              // 最高位为1
    {
        N ++;                 // 结果当前位为1，否则为默认的0
        tmp -= N;
    }
    for (i=15; i>0; i--)      // 求剩余的15位
    {
        N <<= 1;              // 左移一位
        tmp <<= 2;
        tmp += (M >> 30);     // 假设
        ttp = N;
        ttp = (ttp<<1)+1;
        M <<= 2;
        if (tmp >= ttp)       // 假设成立
        {
            tmp -= ttp;
            N ++;
        }
    }
    return N;
}

机器人的应用越来越广泛了，大家熟知的稚晖君直接创业搞机器人，可想而至，接下来的十年，机器人绝对是热门的行业。

目前市面上很多机器人都是基于一套叫做ROS的系统开发的，今天就给大家分享一个跑在MCU上，基于FreeRTOS的轻量级（micro）ROS。

随着市场需求不断的扩大，这种基于MCU的ROS将会越来越普及，对于从事机器人相关工作的读者有必要了解一下。

关于ROS

ROS：Robot Operating System,，即机器人操作系统。

和普通OS（RTOS、TSOS）不一样的是，ROS主要是针对机器人，是基于操作系统之上，提供一系列程序库和工具以帮助软件开发者创建机器人应用软件。它提供了硬件抽象、设备驱动、库函数、可视化、消息传递和软件包管理等诸多功能。ROS遵守BSD开源许可协议。

ROS设计者将ROS表述为“ROS = Plumbing + Tools + Capabilities + Ecosystem”，即ROS是通讯机制、工具软件包、机器人高层技能以及机器人生态系统的集合体。

micro-ROS

本文说的micro-ROS，是基于ROS2进行优化的一套轻量级ROS系统，它提供了完全部署的ROS 2生态系统的大多数吸引人的工具和功能，并具有入式和低资源设备的卓越能力，可以运行在MCU硬件平台。

传统上，即使机器人包含许多ROS，ROS仍停留在微控制器边界。它们通常通过串行协议与旧版ROS中的ROS-serial之类的工具集成在一起。

在微控制器中拥有所有ROS2的功能和相同的API会不是很好吗？这正是micro-ROS提供的-机器人系统嵌入式部分内部的ROS开发生态系统。micro-ROS允许开发人员在硬件级别附近运行ROS 2节点。这使所有硬件外设都可用于该应用程序，从而使其能够直接与SPI或I²C等低级总线进行交互，以与传感器和执行器接口。

微型ROS是一组分层的库，它们可以直接重用ROS 2的库，也可以使其适应资源受限设备的功能和需求。具体来说，如果我们转向ROS 2体系结构，则由微型ROS维护的层是ROS客户端库（RCL）和ROS中间件接口（RMW）。同样，RCLCPP是RCL之上的C ++抽象层，即使大多数与RCL直接接口，它也可以被微型ROS应用程序组件使用。该层在RCLC中提供了相对于ROS 2的附加功能，RCLC是用C99编写的库，其中专门设计和开发了与RCLCPP提供的功能类似的功能，例如便利功能或执行程序，以适合微控制器。 

通常，ROS是基于 Linux系统之上的运行的一套系统，而本文这套微型ROS基于FreeROS运行。

这使micro-ROS在硬件和软件级别上都能与大多数嵌入式平台兼容。

但是，最终构成micro-ROS体系结构的是RMW实现，该实现基于称为Micro XRCE-DDS的中间件库。Micro XRCE-DDS是由对象管理组（OMG）定义和维护的DDS-XRCE（用于极端资源受限环境的DDS）协议的C / C ++实现。

顾名思义，DDS-XRCE是一种有线协议，允许引入以数据为中心的发布者-订阅者DDS模型进入嵌入式世界。DDS-XRCE依赖于客户端-服务器体系结构，其中客户端是用C99编写的轻量级实体，可在低资源设备中运行，而代理（C ++ 11应用程序）则充当客户端与DDS世界之间的桥梁。DDS-XRCE协议负责在这两个实体之间传递请求和消息。相应地，该代理能够通过标准DDS有线协议与DDS全局数据空间进行通信。在DDS世界中，代理通过与其他DDS参与者进行通信来代表客户。该通信由客户端代理，能够通过所有标准DDS实体与DDS进行交互的模拟DDS应用程序进行协调。代理将客户端的状态保存在其内存中，这样，即使代理断开连接，代理也可以存活。代理与客户端之间的通信遵循请求-响应模式，即双向并基于操作和响应。

为什么选择FreeRTOS？

由于它们的轻巧性，XRCE-DDS客户端库和microROS都易于在实时操作系统之上运行，这使它们能够满足其典型目标应用程序所提出的对时间要求严格的要求，其中涉及的任务包括要求时限或确定性响应。

具体来说，FreeRTOS已成为micro-ROS项目支持的首批RTOS之一，因此已集成到其软件堆栈中。这允许重用FreeRTOS社区和合作伙伴提供的所有工具和实现。由于微型ROS软件堆栈是模块化的，因此期望并期望交换软件实体。

FreeRTOS是开发micro ROS和Micro XRCE-DDS应用程序的理想选择。首先，它为许多不同的体系结构和开发工具提供了一个独立的解决方案，它以非常清晰和透明的方式编写，并且拥有非常庞大的用户群，从而确保了大量FreeRTOS用户将能够将其应用程序与微型ROS应用程序集成。而且，它是众所周知的高度可靠的RTOS。至关重要的是，FreeRTOS具有最小的ROM，RAM和处理开销。通常，RTOS内核二进制映像的大小在6K到12K字节之间。由于要与RTOS进行资源竞争，因此，当要最小化MCU上的微型ROS应用程序的内存占用量时，这些内存是理想的选择。

在下文中，我们将讨论FreeRTOS提供的几种功能，以及微型ROS如何利用它们来获利，以优化其堆栈中组成的不同库的所需功能。

任务和计划程序

FreeRTOS提供了一组最少的任务实体，这些实体与调度程序的使用一起，为在应用程序中实现确定性提供了必要的工具。微型ROS客户端库（RCL，RCLC和RCLCPP）访问RTOS的资源，以控制调度和电源管理机制，从而为开发人员提供了优化应用程序的可能性。

FreeRTOS提供的任务有两种：标准任务和空闲任务。前者由用户创建，可以视为RTOS上的应用程序。至关重要的是，将微型ROS应用程序集成到RTOS中作为具有给定优先级的此类任务之一。空闲任务另一方面，优先级较低的任务只有在没有其他任务在运行时才进入运行模式。由于microROS主要针对低功耗和IoT设备，因此这些空闲任务和相关的空闲挂钩非常适合在MCU中启用深度睡眠状态。由于将无状态XRCE-DDS客户端实现为micro-ROS中间件，因此这些深度睡眠状态可能是内存易失的，也就是说，由于面向连接的中间件有线协议，可以使用没有RAM持久性的深度睡眠模式。

使用FreeRTOS调度程序，micro-ROS能够管理其主要任务以及负责传输层的任务的优先级。通常，负责网络堆栈或串行接口的任务必须优先于micro-ROS应用程序。

内存管理

FreeRTOS提供的最令人期望的功能（对于微型ROS开发人员和用户而言非常有趣）是堆栈管理和静态堆栈创建能力。在处理micro-ROS的任务创建时，通常，堆栈分配是关键的设计决策。FreeRTOS允许进行细粒度的堆栈大小管理，这又使程序员可以知道在程序执行期间正在使用多少堆栈内存，或例如确定堆栈内存分配是否存在于静态或动态内存中，从而确定帮助正确使用MCU的内存，这是嵌入式系统中的宝贵资源。至关重要的是，可以为微ROS提供繁重的堆栈使用方任务，并为其分配静态分配的堆栈，从而防止将来出现堆和其他任务初始化问题。

在这方面，值得一提的是，这些内存管理工具为基准化微型ROS和XRCE-DDS的内存占用量提供了理想的框架。具体而言，已进行了彻底的堆栈消耗分析，以评估XRCE-DDS客户端内存消耗。堆栈是程序员在运行应用程序之前未知的内存块。为了对其进行度量，可以使用FreeRTOS uxTaskGetStackHighWaterMark（）函数，该函数返回在执行过程中XRCE-DDS任务堆栈达到最大值时未使用的堆栈量。通过将此值减去总堆栈，可以得到XRCE-DDS应用程序使用的堆栈峰值。用这种方法获得的结果汇总在此处发布的报告中。

我们还注意到，由于FreeRTOS中使用了可插拔的动态内存管理方法，因此micro-ROS能够完成所需的用于管理内存的接口。通过这种方式，已经使用heap_4作为参考实现了诸如calloc（）或realloc（）之类的函数。这些功能在馈入micro-ROS内存管理API之前已被包装，以便分析动态内存消耗。

与静态内存情况类似，FreeRTOS的可交换动态内存管理方法使在嵌入式系统中执行动态内存配置文件分析特别容易。的确，尽管在其他RTOS中，动态（取消）分配功能隐藏在RTOS或标准库的深处，但在FreeRTOS中，它们暴露给用户并易于定制，因此简化了处理和控制动态内存使用的过程。

传输

与客户端支持库访问FreeRTOS的特定原语和功能（例如调度机制）的方式相同，中间件实现Micro XRCE-DDS要求访问RTOS的传输和时间资源以使其正常运行。关于IP传输，在FreeRTOS的特定情况下，Micro XRCE-DDS使用在此RTOS上实现lwIP的附件。lwIP（轻型IP）是为嵌入式系统设计的，广泛使用的开源TCP / IP堆栈，旨在减少资源使用，同时仍提供完整的TCP堆栈。这使得lwIP的使用特别适用于以micro-ROS为目标的嵌入式系统和资源受限的环境。

除了TCP / IP堆栈，lwIP还有其他几个重要部分，例如网络接口，操作系统仿真层，缓冲区和内存管理部分。操作系统仿真层和网络接口允许将网络堆栈移植到操作系统中，因为它提供了lwIP代码和操作系统内核之间的通用接口。

FreeRTOS与lwIP 的集成是从头开始设计的，具有标准且熟悉的接口（伯克利套接字），并且具有线程安全性，旨在使其尽可能易于使用。而且，它可以将缓冲区管理保留在可移植层中。

请注意，XRCE-DDS客户端还支持FreeRTOS + TCP网络堆栈。FreeRTOS + TCP是用于TCP / IP堆栈协议支持的官方FreeRTOS扩展库。

还努力使FreeRTOS + TCP与micro-ROS兼容。这包括对TCP和UDP连接的支持，它们依靠FreeRTOS + TCP API来实现micro XRCE-DDS Client API所要求的抽象层，以便能够使用这些协议与代理进行通信。

此外，还存在使用FreeRTOS的时间测量功能的可能性，从而使XRCE-DDS库能够执行基于时间的任务，从而使用户看不到实现。

Posix扩展

允许将FreeRTOS无缝和盈利地集成到micro-ROS中的另一个显着原因是POSIX扩展的可用性。便携式操作系统接口（POSIX）是IEEE计算机协会为维护操作系统之间的兼容性而指定的一系列标准。FreeRTOS Labs提供的FreeRTOS + POSIX层实现了POSIX API的子集。

确实，尽管micro-ROS中间件具有较低的POSIX依赖关系（只是clock_gettime（）函数），但整个micro-ROS堆栈具有与功能和类型定义相关的更高依赖关系。另外，由于微型ROS项目的基本原理之一是移植或重用Linux（主要是POSIX兼容操作系统）中本机编码的ROS 2的代码，因此使用了某种程度上可与Linux兼容的RTOS。POSIX显然是有益的，因为代码的移植工作量很小。

为此，使用了sleep（）和usleep（）之类的函数。micro-ROS的POSIX类型定义依赖项依赖于FreeRTOS内核中未定义的某些结构，例如struct timeval或struct timespec。还需要诸如type.h，signal.h或unistd.h之类的文件来定义一些标准的类型定义和结构。

对于errno.h，尽管在FreeRTOS + POSIX层中未实现，但出于编译目的，micro-ROS必须包括一些不可用的定义。

通过使用FreeRTOS + FAT库，应在micro-ROS堆栈中重构这些定义，以使FreeRTOS + POSIX具有完全的兼容性。这样，可以完全支持依赖文件系统支持的高级micro-ROS功能，例如日志记录机制。

更多相关教程

如何在FreeRTOS上使用Olimex STM32-E407评估板创建和运行第一个微型ROS应用程序。

随着微电子技术和计算机技术的发展，原来以强电和电器为主、功能简单的电气设备发展成为强、弱电结合，具有数字化特点、功能完善的新型微电子设备。在很多场合，已经出现了越来越多的单片机产品代替传统的电气控制产品。属于存储程序控制的单片机，其控制功能通过软件指令来实现，其硬件配置也可变、易变。因此，一旦生产过程有所变动，就不必重新设计线路连线安装，有利于产品的更新换代和订单式生产。    

传统电气设备采用的各种控制信号，必须转换到与单片机输入/输出口相匹配的数字信号。用户设备须输入到单片机的各种控制信号，如限位开关、操作按钮、选择开关、行程开关以及其他一些传感器输出的开关量等，通过输入电路转换成单片机能够接收和处理的信号。输出电路则应将单片机送出的弱电控制信号转换、放大到现场需要的强输出信号，以驱动功率管、电磁阀和继电器、接触器、电动机等被控制设备的执行元件，能方便实际控制系统使用。    

针对电气控制产品的特点，本文讨论了几种单片机I/O的常用驱动和隔离电路的设计方法，对合理地设计电气控制系统，提高电路的接口能力，增强系统稳定性和抗干扰能力有实际指导意义。

1、 输入电路设计

图1 开关信号输入

一般输入信号最终会以开关形式输入到单片机中，以工程经验来看，开关输入的控制指令有效状态采用低电平比采用高电平效果要好得多，如图1如示。当按下开关S1时，发出的指令信号为低电平，而平时不按下开关S1时，输出到单片机上的电平则为高电平。该方式具有较强的耐噪声能力。    

若考虑到由于TTL电平电压较低，在长线传输中容易受到外界干扰，可以将输入信号提高到+24 V，在单片机入口处将高电压信号转换成TTL信号。这种高电压传送方式不仅提高了耐噪声能力，而且使开关的触点接触良好，运行可靠，如图2所示。其中，D1为保护二极管，反向电压≥50 V。

图2 提高输入信号电平

图3 输入端保护电路    

为了防止外界尖峰干扰和静电影响损坏输入引脚，可以在输入端增加防脉冲的二极管，形成电阻双向保护电路，如图3所示。二极管D1、D2、D3的正向导通压降UF≈0.7 V，反向击穿电压UBR≈30 V，无论输入端出现何种极性的破坏电压，保护电路都能把该电压的幅度限制在输入端所能承受的范围之内。即：VI～VCC出现正脉冲时，D1正向导通；VI～VCC出现负脉冲时，D2反向击穿；VI与地之间出现正脉冲时，D3反向击穿；VI与地之间出现负脉冲时，D3正向导通，二极管起钳位保护作用。缓冲电阻RS约为1.5～2.5 kΩ，与输入电容C构成积分电路，对外界感应电压延迟一段时间。若干扰电压的存在时间小于τ，则输入端承受的有效电压将远低于其幅度；若时间较长，则D1导通，电流在RS上形成一定的压降，从而减小输入电压值。   

此外，一种常用的输入方式是采用光耦隔离电路。如图4所示，R为输入限流电阻，使光耦中的发光二极管电流限制在10～20 mA。输入端靠光信号耦合，在电气上做到了完全隔离。同时，发光二极管的正向阻抗值较低，而外界干扰源的内阻一般较高，根据分压原理，干扰源能馈送到输入端的干扰噪声很小，不会产生地线干扰或其他串扰，增强了电路的抗干扰能力。

图4 输入端光耦隔离

在满足功能的前提下，提高单片机输入端可靠性最简单的方案是：在输入端与地之间并联一只电容来吸收干扰脉冲，或串联一只金属薄膜电阻来限制流入端口的峰值电流。

2、 输出电路设计    

单片机输出端口受驱动能力的限制，一般情况下均需专用的接口芯片。其输出虽因控制对象的不同而千差万别，但一般情况下均满足对输出电压、电流、开关频率、波形上升下降速率和隔离抗干扰的要求。在此讨论几种典型的单片机输出端到功率端的电路实现方法。

2.1 直接耦合    

在采用直接耦合的输出电路中，要避免出现图5所示的电路。

图5 错误的输出电路    

T1截止、T2导通期间，为了对T2提供足够的基极电流，R2的阻值必须很小。因为T2处于射极跟随器方式工作，因此为了减少T2损耗，必须将集射间电压降控制在较小范围内。这样集基间电压也很小，电阻R2阻值很小才能提供足够的基极电流。R2阻值过大，会大幅度增加T2压降，引起T2发热严重。而在T2截止期间，T1必须导通，高压+15 V全部降在电阻R2上，产生很大的电流，显然是不合理的。另外，T1的导通将使单片机高电平输出被拉低至接近地电位，引起输出端不稳定。T2基极被T1拉到地电位，若其后接的是感性负载，由于绕组反电势的作用，T2的发射极可能存在高电平，容易引起T2管基射结反向击穿。    

图6为一直接耦合输出电路，由T1和T2组成耦合电路来推动T3。T1导通时，在R3、R4的串联电路中产生电流，在R3上的分压大于T2晶体管的基射结压降，促使T2导通，T2提供了功率管T3的基极电流，使T3变为导通状态。当T1输入为低电平时，T1截止，R3上压降为零，T2截止，最终T3截止。R5的作用在于：一方面作为T2集电极的一个负载，另一方面T2截止时，T3基极所储存的电荷可以通过电阻R3迅速释放，加快T3的截止速度，有利于减小损耗。

图6 直接耦合输出电路

2.2 TTL或CMOS器件耦合    

若单片机通过TTL或CMOS芯片输出，一般均采用集电极开路的器件，如图7(a)所示。集电极开路器件通过集电极负载电阻R1接至+15 V电源，提升了驱动电压。但要注意的是，这种电路的开关速度低，若用其直接驱动功率管，则当后续电路具有电感性负载时，由于功率管的相位关系，会影响波形上升时间，造成功率管动态损耗增大。    

为了改善开关速度，可采用2种改进形式输出电路，如图7(b)和图7(c)所示。图7(b)是能快速开通的改进电路，当TTL输出高电平时，输出点通过晶体管T1获得电压和电流，充电能力提高，从而加快开通速度，同时也降低了集电极开路TTL器件上的功耗。图7(c)为推挽式的改进电路，采用这种电路不但可提高开通时的速度，而且也可提高关断时的速度。输出晶体管T1是作为射极跟随器工作的，不会出现饱和，因而不影响输出开关频率。

图7 TTL或CMOS器件输出电路

2.3 脉冲变压器耦合    

脉冲变压器是典型的电磁隔离元件，单片机输出的开关信号转换成一种频率很高的载波信号，经脉冲变压器耦合到输出级。由于脉冲变压器原、副边线圈间没有电路连接，所以输出是电平浮动的信号，可以直接与功率管等强电元件耦合，如图8所示。

图8 脉冲变压器输出电路    

这种电路必须有一个脉冲源，脉冲源的频率是载波频率，应至少比单片机输出频率高10倍以上。脉冲源的输出脉冲送入控制门G，单片机输出信号由另一端输入G门。当单片机输出高电平时，G门打开，输出脉冲进入变压器，变压器的副线圈输出与原边相同频率的脉冲，通过二极管D1、D2检波后经滤波还原成开关信号，送入功率管。当单片机输出低电平时，G门关闭，脉冲源不能通过G门进入变压器，变压器无输出。    

这里，变压器既传递信号，又传送能量，提高了脉冲源的频率，有利于减轻变压器的体重。由于变压器可通过调整电感量、原副边匝数等来适应不同推动功率的要求，所以应用起来比较灵活。更重要的是，变压器原副边线圈之间没有电的联系，副线圈输出信号可以跟随功率元件的电压而浮动，不受其电源大小的影响。 

当单片机输出较高频率的脉冲信号时，可以不采用脉冲源和G门，对变压器原副边电路作适当调整即可。

2.4 光电耦合    

光电耦合可以传输线性信号，也可以传输开关信号，在输出级应用时主要用来传递开关信号。如图9所示，单片机输出控制信号经缓冲器7407放大后送入光耦。R2为光耦输出晶体管的负载电阻，它的选取应保证：在光耦导通时，其输出晶体管可靠饱和；而在光耦截止时，T1可靠饱和。但由于光耦响应速度慢使开关延迟时间加长，限制了其使用频率。

图9 光耦输出电路

结语    

单片机接口技术在很多文献中均有详细的介绍，但在对大量电气控制产品的改造和设计中，经常会碰到用接口芯片所无法解决的问题（如驱动电流大、开关速度慢、抗干扰差等），因此必须寻求另一种电路解决方案。上述几种输入/输出电路通过广泛的应用表明，其对合理、可靠地实现单片机电气控制系统具有较高的工程实用价值。

这个地方就是单片机内部的只读存储器即ROM（READ ONLY MEMORY）。为什么称它为只读存储器呢？刚才我们不是明明把两个数字写进去了吗？

原来在 89C51 中的 ROM 是一种电可擦除的 ROM，称为 FLASH ROM，刚才我们是用的编程器，在特殊的条件下由外部设备对 ROM 进行写的操。在单片机正常工作条件下，只能从那面读，不能把数据写进去，所以我们还是把它称为 ROM。

二、几个基本概念

1、数的本质和物理现象

我们知道，计算机可以进行数学运算，这令我们非常难以理解，计算机嘛，我们虽不了解它的组成，但它们只是一些电子元器件，怎么可以进行数学运算呢？

我们做数学题如 37+45 是这样做的，先在纸上写 37，然后在下面写 45，然后大脑运算，最后写出结果。运算的原材料：37、45 和结果：82 都是写在纸上的，计算机中又是放在什么地方呢？

为了解决这个问题，先让我们做一个实验：这里有一盏灯，我们知道灯要么亮，要么不亮，就有两种状态，我们可以用 ’0’ 和 ’1’ 来代替这两种状态，规定亮为 ’1’，不亮为 ’0’。现在放上两盏灯，一共有几种状态呢？我们列表来看一下：

请大家自己写上 3 盏灯的情况 000  001  010  011  100  101  110  111。我们来看，这个 000，001，101 不就是我们学过的的二进制数吗？本来，灯的亮和灭只是一种物理现象，可当我们把它们按一定的顺序排好后，灯的亮和灭就代表了数字了。

让我们再抽象一步，灯为什么会亮呢？是因为输出电路输出高电平，给灯通了电。因此，灯亮和灭就可以用电路的输出是高电平还是低电平来替代了。这样，数字就和电平的高、低联系上了。（请想一下，我们还看到过什么样的类似的例子呢？（海军之）灯语、旗语，电报，甚至红、绿灯）。

2、位的含义

通过上面的实验我们已经知道：一盏灯亮或者说一根线的电平的高低，可以代表两种状态：0 和 1。实际上这就是一个二进制位，因此我们就把一根线称之为一“位”，用BIT 表示。

3、字节的含义

一根线可以表示 0 和 1，两根线可以表达 00，01，10，11 四种状态，也就是可以表达 0 到 3，而三根可以表达 0~7，计算机中通常用 8 根线放在一起，同时计数，就可以表示 0-255 一共 256 种状态。这 8 根线或者 8 位就称之为一个字节（BYTE）。

三、存储器的工作原理

1、存储器构造

存储器就是用来存放数据的地方。它是利用电平的高低来存放数据的，也就是说，它存放的实际上是电平的高、低，而不是我们所习惯认为的 1234 这样的数字，这样，我们的一个谜团就解开了，计算机也没什么神秘的嘛。

如上图左所示：一个存储器就象一个个的小抽屉，一个小抽屉里有八个小格子，每个小格子就是用来存放“电荷”的，电荷通过与它相连的电线传进来或释放掉，至于电荷在小格子里是怎样存的，就不用我们操心了，你可以把电线想象成水管，小格子里的电荷就象是水，那就好理解了。存储器中的每个小抽屉就是一个放数据的地方，我们称之为一个“单元”。

有了这么一个构造，我们就可以开始存放数据了，想要放进一个数据12，也就是00001100，我们只要把第二号和第三号小格子里存满电荷，而其它小格子里的电荷给放掉就行了（看上图右）。

可是问题出来了，看上图右，一个存储器有好多单元，线是并联的，在放入电荷的时候，会将电荷放入所有的单元中，而释放电荷的时候，会把每个单元中的电荷都放掉，这样的话，不管存储器有多少个单元，都只能放同一个数，这当然不是我们所希望的。

因此，要在结构上稍作变化，看上图右，在每个单元上有个控制线，我想要把数据放进哪个单元，就把一个信号给这个单元的控制线，这个控制线就把开关打开，这样电荷就可以自由流动了，而其它单元控制线上没有信号，所以开关不打开，不会受到影响，这样，只要控制不同单元的控制线，就可以向各单元写入不同的数据了，同样，如果要从某个单元中取数据，也只要打开相应的控制开关就行了。

2、存储器译码

那么，我们怎样来控制各个单元的控制线呢？这个还不简单，把每个单元的控制线都引到集成电路的外面不就行了吗。

事情可没那么简单，一片 27512 存储器中有 65536 个单元，把每根线都引出来，这个集成电路就得有 6 万多个脚。不行，怎么办？要想法减少线的数量。

我们有一种方法称这为译码，简单介绍一下：一根线可以代表 2 种状态，2 根线可以代表 4 种状态，3 根线可以代表几种，256 种状态又需要几根线代表？8 种，8 根线。所以 65536 种状态我们只需要 16 根线就可以代表了。

3、存储器的选片及总线的概念

至此，译码的问题解决了，让我们再来关注另外一个问题。送入每个单元的八根线是用从什么地方来的呢？

它就是从计算机上接过来的，一般地，这八根线除了接一个存储器之外，还要接其它的器件。这样问题就出来了，这八根线既然不是存储器和计算机之间专用的，如果总是将某个单元接在这八根线上，就不好了，比如这个存储器单元中的数值是 0FFH 另一个存储器的单元是 00H，那么这根线到底是处于高电平，还是低电平？岂非要打架看谁历害了？

所以我们要让它们分离。办法当然很简单，当外面的线接到集成电路的引脚进来后，不直接接到各单元去，中间再加一组开关就行了。平时我们让开关打开着，如果确实是要向这个存储器中写入数据，或要从存储器中读出数据，再让开关接通就行了。这组开关由三根引线选择：读控制端、写控制端和片选端。

要将数据写入片中，先选中该片，然后发出写信号，开关就合上了，并将传过来的数据（电荷）写入片中。如果要读，先选中该片，然后发出读信号，开关合上，数据就被送出去了。读和写信号同时还接入到另一个存储器，但是由于片选端不同，所以虽有读或写信号，但没有片选信号，所以另一个存储器不会“误会”而开门，造成冲突。

那么会不会同时选中两片芯片呢？只要是设计好的系统就不会，因为它是由计算控制的，而不是我们人来控制的，如果真的出现同时出现选中两片的情况，那就是电路出了故障了，这不在我们的讨论之列。

从上面的介绍中我们已经看到，用来传递数据的八根线并不是专用的，而是很多器件大家共用的，所以我们称之为数据总线，总线英文名为 BUS，总即公交车道，谁也可以走。而十六根地址线也是连在一起的，称之为地址总线。

文章来源于网络、一起学嵌入式，版权归原作者所有，如有侵权，请联系删除。