打印
[51单片机]

从业将近十年!手把手教你单片机程序框架(连载)

[复制链接]
楼主: jianhong_wu
手机看帖
扫描二维码
随时随地手机跟帖
421
zxb忘记| | 2014-7-12 08:27 | 只看该作者 回帖奖励 |倒序浏览
学习》》》》》》》

使用特权

评论回复
422
yorking1814| | 2014-7-13 01:06 | 只看该作者
鸿哥,求通讯方面的内容,CAN,SPI,I2C等!!

使用特权

评论回复
423
jianhong_wu|  楼主 | 2014-7-13 07:46 | 只看该作者
第五十七节:为指针加上紧箍咒const,避免意外修改了只做输入接口的数据。

开场白:
通过上一节的学习,我们知道指针在函数接口中具有双向性,这个双向性是一把双刃剑,既给我们带来便捷,也给我们带来隐患。这一节要教大家以下知识点:
凡是做输入接口的指针,都应该加上const标签来标识,它可以让原来双向性的接口变成了单向性接口,它有两个好处:
第一个:如果你是用别人已经封装好的函数,你发现接口指针带了const标签,就足以说明这个指针只能做输入接口,你用了它,不用担心输入数据被修改。
第二个:如果是你自己写的函数,你在输入接口处的指针加了const标签,它可以预防你在写函数内部代码时不小心修改了输入接口的数据。比如,你试着在函数内部更改带const标签的输入接口数据,当你点击编译时,会编译不过,出现错误提示:error C183: unmodifiable lvalue。这就是一道防火墙啊!

具体内容,请看源代码讲解。

(1)硬件平台:
基于朱兆祺51单片机学习板。

(2)实现功能:
我只是把第55节中凡是输入接口数据的指针都加了const关键字标签,其它代码内容没变。
把5个随机数据按从大到小排序,用冒泡法来排序。
通过电脑串口调试助手,往单片机发送EB 00 55 08 06 09 05 07  指令,其中EB 00 55是数据头,08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据,最前面5个数据是第3种方法的排序结果,中间3个数据EE EE EE是第3种和第4种的分割线,为了方便观察,没实际意义。最后5个数据是第4种方法的排序结果.

比如电脑发送:EB 00 55 08 06 09 05 07
单片机就返回:09 08 07 06 05 EE EE EE 09 08 07 06 05

波特率是:9600 。

(3)源代码讲解如下:
#include "REG52.H"


#define const_array_size  5  //参与排序的数组大小

#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_rc_size  10  //接收串口中断数据的缓冲区数组大小

#define const_receive_time  5  //如果超过这个时间没有串口数据过来,就认为一串数据已经全部接收完,这个时间根据实际情况来调整大小

void initial_myself(void);   
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void delay_short(unsigned int uiDelayShort);


void T0_time(void);  //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void);  //串口服务程序,在main函数里


void eusart_send(unsigned char ucSendData);


void big_to_small_sort_2(const unsigned char *p_ucInputBuffer);//第2种方法 把一个数组从大到小排序
void big_to_small_sort_3(const unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer);//第3种方法 把一个数组从大到小排序
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned int  uiSendCnt=0;     //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1;    //串口服务程序的自锁变量,每次接收完一串数据只处理一次
unsigned int  uiRcregTotal=0;  //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int  uiRcMoveIndex=0;  //用来解析数据协议的中间变量

unsigned char ucUsartBuffer[const_array_size];  //从串口接收到的需要排序的原始数据

unsigned char ucGlobalBuffer_2[const_array_size]; //第2种方法,参与具体排序算法的全局变量数组
unsigned char ucGlobalBuffer_3[const_array_size]; //第3种方法,用来接收输出接口数据的全局变量数组

void main()
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral();
   while(1)  
   {
       usart_service();  //串口服务程序
   }

}


void big_to_small_sort_2(const unsigned char *p_ucInputBuffer)//第2种方法 把一个数组从大到小排序
{
   unsigned char i;
   unsigned char k;
   unsigned char ucTemp; //在两两交换数据的过程中,用于临时存放交换的某个变量


   for(i=0;i<const_array_size;i++)  
   {
      ucGlobalBuffer_2[i]=p_ucInputBuffer[i];  //参与排序算法之前,先把输入接口的数据全部搬移到全局变量数组中。
   }


   //以下就是著名的 冒泡法排序。详细讲解请找百度。
   for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
   {
      for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中,需要两两比较的次数是(const_array_size-1-i)
          {
             if(ucGlobalBuffer_2[const_array_size-1-k]>ucGlobalBuffer_2[const_array_size-1-1-k])  //后一个与前一个数据两两比较
                 {
                     ucTemp=ucGlobalBuffer_2[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
             ucGlobalBuffer_2[const_array_size-1-1-k]=ucGlobalBuffer_2[const_array_size-1-k];
             ucGlobalBuffer_2[const_array_size-1-k]=ucTemp;
                 }
         
          }
   }


}



/* 注释一:
* 凡是做输入接口的指针,都应该加上const标签来标识,它可以让原来双向性的接口变成了单向性接口,它有两个好处:
* 第一个:如果你是用别人已经封装好的函数,你发现接口指针带了const标签,就足以说明
* 这个指针只能做输入接口,你用了它,不用担心输入数据被修改。
* 第二个:如果是你自己写的函数,你在输入接口处的指针加了const标签,它可以预防你在写函数内部代码时
* 不小心修改了输入接口的数据。比如,你试着在以下函数最后的地方加一条更改输入接口数据的指令,
* 当你点击编译时,会编译不过,出现错误提示:error C183: unmodifiable lvalue。
*/
void big_to_small_sort_3(const unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer)//第3种方法 把一个数组从大到小排序
{
   unsigned char i;
   unsigned char k;
   unsigned char ucTemp; //在两两交换数据的过程中,用于临时存放交换的某个变量
   unsigned char ucBuffer_3[const_array_size]; //第3种方法,参与具体排序算法的局部变量数组

   for(i=0;i<const_array_size;i++)  
   {
      ucBuffer_3[i]=p_ucInputBuffer[i];  //参与排序算法之前,先把输入接口的数据全部搬移到局部变量数组中。
   }


   //以下就是著名的 冒泡法排序。详细讲解请找百度。
   for(i=0;i<(const_array_size-1);i++)  //冒泡的次数是(const_array_size-1)次
   {
      for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中,需要两两比较的次数是(const_array_size-1-i)
          {
             if(ucBuffer_3[const_array_size-1-k]>ucBuffer_3[const_array_size-1-1-k])  //后一个与前一个数据两两比较
                 {
                     ucTemp=ucBuffer_3[const_array_size-1-1-k];     //通过一个中间变量实现两个数据交换
             ucBuffer_3[const_array_size-1-1-k]=ucBuffer_3[const_array_size-1-k];
             ucBuffer_3[const_array_size-1-k]=ucTemp;
                 }
         
          }
   }


   for(i=0;i<const_array_size;i++)  
   {
      p_ucOutputBuffer[i]=ucBuffer_3[i];  //参与排序算法之后,把运算结果的数据全部搬移到输出接口中,方便外面程序调用
   }


/* 注释二:
* 以下这条是企图修改输入接口数据的指令,如果不屏蔽,编译的时候就会出错提醒:error C183: unmodifiable lvalue?
*/

   //p_ucInputBuffer[0]=0;  //修改输入接口数据的指令
}




void usart_service(void)  //串口服务程序,在main函数里
{

     unsigned char i=0;   

     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内,再也没有新数据从串口来
     {

            ucSendLock=0;    //处理一次就锁起来,不用每次都进来,除非有新接收的数据

            //下面的代码进入数据协议解析和数据处理的阶段

            uiRcMoveIndex=0; //由于是判断数据头,所以下标移动变量从数组的0开始向最尾端移动

            while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {


                                  for(i=0;i<const_array_size;i++)
                                  {
                     ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
                                  }


                  //第2种运算方法,依靠指针为函数增加一个数组的输入接口
                                  //通过指针输入接口,直接把ucUsartBuffer数组的首地址传址进去,排序后输出的结果还是保存在ucGlobalBuffer_2全局变量数组中
                  big_to_small_sort_2(ucUsartBuffer);
                  for(i=0;i<const_array_size;i++)
                                  {
                                    eusart_send(ucGlobalBuffer_2[i]);  //把用第2种方法排序后的结果返回给上位机观察
                                  }


                                  eusart_send(0xee);  //为了方便上位机观察,多发送3个字节ee ee ee作为第2种方法与第3种方法的分割线
                                  eusart_send(0xee);
                                  eusart_send(0xee);

                  //第3种运算方法,依靠指针为函数增加一个数组的输出接口
                                  //通过指针输出接口,排序运算后的结果直接从这个输出口中导出到ucGlobalBuffer_3数组中
                  big_to_small_sort_3(ucUsartBuffer,ucGlobalBuffer_3);   //ucUsartBuffer是输入的数组,ucGlobalBuffer_3是接收排序结果的数组
                  for(i=0;i<const_array_size;i++)
                                  {
                                    eusart_send(ucGlobalBuffer_3[i]);  //把用第3种方法排序后的结果返回给上位机观察
                                  }



                  break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头,游标向着数组最尾端的方向移动
           }
                                         
           uiRcregTotal=0;  //清空缓冲的下标,方便下次重新从0下标开始接受新数据
  
     }
                        
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时,这里非常关键,也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



void T0_time(void) interrupt 1    //定时中断
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断


  if(uiSendCnt<const_receive_time)   //如果超过这个时间没有串口数据过来,就认为一串数据已经全部接收完
  {
          uiSendCnt++;    //表面上这个数据不断累加,但是在串口中断里,每接收一个字节它都会被清零,除非这个中间没有串口数据过来
      ucSendLock=1;     //开自锁标志
  }



  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}


void usart_receive(void) interrupt 4                 //串口接收数据中断        
{        

   if(RI==1)  
   {
        RI = 0;

            ++uiRcregTotal;
        if(uiRcregTotal>const_rc_size)  //超过缓冲区
        {
           uiRcregTotal=const_rc_size;
        }
        ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
        uiSendCnt=0;  //及时喂狗,虽然main函数那边不断在累加,但是只要串口的数据还没发送完毕,那么它永远也长不大,因为每个中断都被清零。
   
   }
   else  //发送中断,及时把发送中断标志位清零
   {
        TI = 0;
   }
                                                         
}                                


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}

void delay_short(unsigned int uiDelayShort)
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


void initial_myself(void)  //第一区 初始化单片机
{

  beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  //配置定时器
  TMOD=0x01;  //设置定时器0为工作方式1
  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;


  //配置串口
  SCON=0x50;
  TMOD=0X21;
  TH1=TL1=-(11059200L/12/32/9600);  //这段配置代码具体是什么意思,我也不太清楚,反正是跟串口波特率有关。
  TR1=1;

}

void initial_peripheral(void) //第二区 初始化外围
{

   EA=1;     //开总中断
   ES=1;     //允许串口中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断

}
总结陈词:
    通过前面几节的学习,我们知道了指针在函数接口中的输入输出用途,以及const关键字的作用。下一节将要讲指针的第五大好处。欲知详情,请听下回分解-----指针的第五大好处,指针在众多数组中的中转站作用。

(未完待续,下节更精彩,不要走开哦)

使用特权

评论回复
424
jianhong_wu|  楼主 | 2014-7-13 07:58 | 只看该作者
yorking1814 发表于 2014-7-13 01:06
鸿哥,求通讯方面的内容,CAN,SPI,I2C等!!

CAN我没用过。SPI请参考我的第48节,DS1302时钟芯片就是SPI通讯。I2C请参考我的第46节,AT24C02就是I2C通讯。另外,我跟你分享一下我的经验。其实我从来不刻意去学,也不刻意去**CAN,SPI,I2C,232,485等通讯,因为在我的脑海里,世界上只有串行通讯和并行通讯这两种,以及它们应用在哪些场合,其它的我都不记。比如在我脑海里,CAN,SPI,I2C,232,485都是属于串行通讯。CAN类似局域网。SPI一般是有3个IO口驱动,输入和输出IO口分开。I2C只有2个IO口驱动,需要带上拉电阻,在总线上最多可以挂8个器件。232是跟电脑通讯。485可以远距离通讯,最大可以挂32个从机。至于其它具体的细节,其实我是没有印象的,而且也没必要记,需要用的时候查资料看一下就可以了。

使用特权

评论回复
评分
参与人数 1威望 +1 收起 理由
yorking1814 + 1 很给力!
425
huzeng168| | 2014-7-13 12:25 | 只看该作者
期待中。。。

使用特权

评论回复
426
gyjxdh| | 2014-7-13 16:33 | 只看该作者
真不错,东西详细,一定付出很多,拿出来给大家分享,懂得奉献。支持,顶一个

使用特权

评论回复
427
trione| | 2014-7-13 23:50 | 只看该作者
收益匪浅呀
学习了感谢楼主

使用特权

评论回复
428
frlop| | 2014-7-14 07:46 | 只看该作者
mark。
LZ辛苦了。

使用特权

评论回复
429
jianhong_wu|  楼主 | 2014-7-20 07:09 | 只看该作者
本帖最后由 jianhong_wu 于 2014-7-20 12:36 编辑

第五十八节:指针的第五大好处,指针在众多数组中的中转站作用。
开场白:
    单个变量数据之间可以通过一条指令任意自由赋值转移,但是数组之间不能通过一条指令直接赋值转移,必须用for等循环指令挨个把数组的数据一个一个来赋值转移,如果一个 函数中,有很多数组需要赋值转移,那就非常麻烦了,要用很多for语句,耗时。还好C语言里有个指针,它可以非常高效地来切换我们所需要的数组,起到很好的中转站作用。这一节要教大家一个知识点:指针在众多数组中的中转站作用。
具体内容,请看源代码讲解。
1)硬件平台:
基于朱兆祺51单片机学习板。
2)实现功能:
在第57节的串口收发程序基础上修改。在串口接收函数中,以下代码有略微修改:
while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4))//注意,这里是4,不是上一节的5,因为只有eb 00 55 xx4个数据
通过上位机来调用下位机对应的数组数据。
通过电脑串口调试助手,往单片机发送EB 00 55 XX 指令,其中EB 00 55是数据头,XX的取值范围是0x01 0x05,每个不同的值代表调用下位机不同的数组数据。0x01调用第1组数据,0x02调用第2组数据,0x05调用第5组数据。
1组:11 12 13 14 15
2组:21 22 23 24 25
3组:31 32 33 34 35
4组:41 42 43 44 45
5组:51 52 53 54 55
下位机返回21个数据,前面5个是第1种不带指针函数返回的数据。中间5个是第2种不带指针函数返回的数据。最后5个是第3种带指针函数返回的数据。期间2EE EE EE是各函数返回的数据分割线,为了方便观察,没实际意义。
比如电脑发送:EB 0055 02
单片机就返回:21 2223 24 25 EE EE EE 21 22 23 24 25 EE EE EE 21 22 23 24 25
波特率是:9600
3)源代码讲解如下:
#include "REG52.H"


#define const_array_size  5  //参与排序的数组大小

#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_rc_size  10  //接收串口中断数据的缓冲区数组大小

#define const_receive_time  5  //如果超过这个时间没有串口数据过来,就认为一串数据已经全部接收完,这个时间根据实际情况来调整大小

void initial_myself(void);   
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void delay_short(unsigned int uiDelayShort);


void T0_time(void);  //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void);  //串口服务程序,在main函数里
void send_array_1(unsigned char ucArraySec);  //第1种函数,不带指针
void send_array_2(unsigned char ucArraySec);  //第2种函数,不带指针
void send_array_3(unsigned char ucArraySec);  //第3种函数,带指针
void eusart_send(unsigned char ucSendData);


sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned int  uiSendCnt=0;     //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1;    //串口服务程序的自锁变量,每次接收完一串数据只处理一次
unsigned int  uiRcregTotal=0;  //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int  uiRcMoveIndex=0;  //用来解析数据协议的中间变量

const unsigned char array_0x01[]={0x11,0x12,0x13,0x14,0x15}; //第1个常量数组
const unsigned char array_0x02[]={0x21,0x22,0x23,0x24,0x25}; //第2个常量数组
const unsigned char array_0x03[]={0x31,0x32,0x33,0x34,0x35}; //第3个常量数组
const unsigned char array_0x04[]={0x41,0x42,0x43,0x44,0x45}; //第4个常量数组
const unsigned char array_0x05[]={0x51,0x52,0x53,0x54,0x55}; //第5个常量数组

void main()
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral();
   while(1)  
   {
       usart_service();  //串口服务程序
   }

}

/* 注释一:
* 第1种函数,内部不带指针,根据上位机相关的指令,
* 直接返回对应的数组。由于不带指针,因此多用了5个for循环来搬运数组。
* 比较耗程序ROM容量,也不够简洁清晰。
*/
void send_array_1(unsigned char ucArraySec)
{
   unsigned int i;
   switch(ucArraySec)
   {
      case 1:  //直接返回第1个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x01[i]);
                   }
               break;
      case 2:  //直接返回第2个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x02[i]);
                   }
               break;
      case 3:  //直接返回第3个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x03[i]);
                   }
               break;
      case 4:  //直接返回第4个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x04[i]);
                   }
               break;   
      case 5:  //直接返回第5个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x05[i]);
                   }
               break;

   }
  
}


/* 注释二:
* 第2种函数,内部不带指针,根据上位机相关的指令,
* 先转移对应的数组放到一个中间变量数组,然后发送数组。
* 由于不带指针,因此多用了6个for循环来搬运数组。
* 跟第1种函数一样,比较耗程序ROM容量,也不够简洁清晰。
*/
void send_array_2(unsigned char ucArraySec)  //第2种函数,不带指针
{
   unsigned int i;
   unsigned char array_temp[5]; //临时中间数组
   switch(ucArraySec)
   {
      case 1:  //直接返回第1个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x01[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;
      case 2:  //直接返回第2个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x02[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;
      case 3:  //直接返回第3个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x03[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;
      case 4:  //直接返回第4个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x04[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;   
      case 5:  //直接返回第5个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x05[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;

   }

   for(i=0;i<5;i++)
   {
           eusart_send(array_temp[i]);  //把临时存放在中间数组的数据全部发送出去
   }

}

/* 注释三:
* 第3种函数,内部带指针,根据上位机相关的指令,
* 先把对应的数组首地址传递给一个中间指针,然后再通过
* 指针把整个数组的数据发送出去,由于带指针,切换转移数组的数据非常快,
* 只需传递一下首地址给指针就可以,非常高效,整个函数只用了1个for循环。
* 跟前面第1,2种函数相比,更加节省程序容量,处理速度更加快,更加简洁。
*/
void send_array_3(unsigned char ucArraySec)  //第3种函数,带指针
{
   unsigned int i;
   unsigned char *p_array; //临时中间指针,作为数组的中转站,非常高效
   switch(ucArraySec)
   {
      case 1:  //直接返回第1个常量数组
                   p_array=array_0x01;  //把数组的首地址传递给指针,一个指令就可以,不用for来挨个搬移数据,高效!
               break;
      case 2:  //直接返回第2个常量数组
                   p_array=array_0x02;  //把数组的首地址传递给指针,一个指令就可以,不用for来挨个搬移数据,高效!
               break;
      case 3:  //直接返回第3个常量数组
                   p_array=array_0x03;  //把数组的首地址传递给指针,一个指令就可以,不用for来挨个搬移数据,高效!
               break;
      case 4:  //直接返回第4个常量数组
                   p_array=array_0x04;  //把数组的首地址传递给指针,一个指令就可以,不用for来挨个搬移数据,高效!
               break;   
      case 5:  //直接返回第5个常量数组
                   p_array=array_0x05;  //把数组的首地址传递给指针,一个指令就可以,不用for来挨个搬移数据,高效!
               break;

   }

   for(i=0;i<5;i++)
   {
           eusart_send(p_array[i]);  //通过指针把数组的数据全部发送出去
   }

}

void usart_service(void)  //串口服务程序,在main函数里
{

     unsigned char i=0;   
     unsigned char ucWhichArray;
     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内,再也没有新数据从串口来
     {

            ucSendLock=0;    //处理一次就锁起来,不用每次都进来,除非有新接收的数据

            //下面的代码进入数据协议解析和数据处理的阶段

            uiRcMoveIndex=0; //由于是判断数据头,所以下标移动变量从数组的0开始向最尾端移动

            while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4)) //注意,这里是4,不是上一节的5,因为只有eb 00 55 xx这4个数据
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {

                   ucWhichArray=ucRcregBuf[uiRcMoveIndex+3]; //上位机需要返回的某个数组

                   send_array_1(ucWhichArray); //第1种函数返回数组的5个数据,不带指针

                   eusart_send(0xee);  //为了方便上位机观察,多发送3个字节ee ee ee作为分割线
                   eusart_send(0xee);
                   eusart_send(0xee);

                   send_array_2(ucWhichArray); //第2种函数返回数组的5个数据,不带指针

                   eusart_send(0xee);  //为了方便上位机观察,多发送3个字节ee ee ee作为分割线
                   eusart_send(0xee);
                   eusart_send(0xee);

                   send_array_3(ucWhichArray); //第3种函数返回数组的5个数据,带指针


                   break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头,游标向着数组最尾端的方向移动
           }
                                         
           uiRcregTotal=0;  //清空缓冲的下标,方便下次重新从0下标开始接受新数据
  
     }
                        
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时,这里非常关键,也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



void T0_time(void) interrupt 1    //定时中断
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断


  if(uiSendCnt<const_receive_time)   //如果超过这个时间没有串口数据过来,就认为一串数据已经全部接收完
  {
      uiSendCnt++;    //表面上这个数据不断累加,但是在串口中断里,每接收一个字节它都会被清零,除非这个中间没有串口数据过来
      ucSendLock=1;     //开自锁标志
  }



  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}


void usart_receive(void) interrupt 4                 //串口接收数据中断        
{        

   if(RI==1)  
   {
        RI = 0;

        ++uiRcregTotal;
        if(uiRcregTotal>const_rc_size)  //超过缓冲区
        {
           uiRcregTotal=const_rc_size;
        }
        ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
        uiSendCnt=0;  //及时喂狗,虽然main函数那边不断在累加,但是只要串口的数据还没发送完毕,那么它永远也长不大,因为每个中断都被清零。
   
   }
   else  //发送中断,及时把发送中断标志位清零
   {
        TI = 0;
   }
                                                         
}                                


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}

void delay_short(unsigned int uiDelayShort)
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


void initial_myself(void)  //第一区 初始化单片机
{

  beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  //配置定时器
  TMOD=0x01;  //设置定时器0为工作方式1
  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;


  //配置串口
  SCON=0x50;
  TMOD=0X21;
  TH1=TL1=-(11059200L/12/32/9600);  //这段配置代码具体是什么意思,我也不太清楚,反正是跟串口波特率有关。
  TR1=1;

}

void initial_peripheral(void) //第二区 初始化外围
{

   EA=1;     //开总中断
   ES=1;     //允许串口中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断

}

总结陈词:
通过前面几节的学习,基本上讲完了我平时用指针的所有心得体会。
下一节开始讲新内容。在前面一些章节中,我提到为了防止中断函数把某些共享数据破坏,在主函数中更改某个数据变量时,应该先关闭中断,修改完后再打开中断;我也提到了网友“红金龙吸味”关于原子锁的建议。经过这段时间的思考和总结,我发现不管是关中断开中断,还是原子锁,其实本质上都是程序在多进程中临界点的数据处理,原子锁在程序员中有个专用名词叫互斥量,而我引以为豪的状态机程序框架,主函数的switch语句,外加一个定时中断,本质上就是2个独立进程在不断切换并行运行。我觉得这个临界点处理的知识很重要,也很容易忽略,所以我决定专门用两节内容来讲讲这方面的知识应用。欲知详情,请听下回分解-----关中断和开中断在多进程临界点的应用。
(未完待续,下节更精彩,不要走开哦)

使用特权

评论回复
430
kamen588| | 2014-7-20 11:07 | 只看该作者
非常赞赏楼主的乐于分享,如果有更多的人像楼主一样,会更好的推动技术的发展。
相比有些只说风凉话,没见拿出什么有价值的分享的人,楼主的所作所为已经超越他们太多了。
不必介意批评你的声音,支持你的是大多数。
三人行必有我师,我也从楼主这里学到了很多。
谢谢,继续努力 我顶你

使用特权

评论回复
431
jianhong_wu|  楼主 | 2014-7-20 12:10 | 只看该作者
kamen588 发表于 2014-7-20 11:07
非常赞赏楼主的乐于分享,如果有更多的人像楼主一样,会更好的推动技术的发展。
相比有些只说风凉话,没见 ...

感谢你的支持,理解和夸奖。我现在越来越感觉,只有把自己有价值的东西分享出去,让更加多人受益,这样的人生才会更加充实,对社会有贡献,对自己也有提升和无形的回报,这是一种良性循环的正能量。

使用特权

评论回复
432
jianhong_wu|  楼主 | 2014-7-21 00:44 | 只看该作者
第五十九节:串口程序第40,44,45节中存在一个bug,特此紧急公告。
                                 
   经过网友“intech2008”的提醒,在我之前发表的第40,44,45节串口接收程序中,在计算检验和的地方,存在一个不容易发觉的bug。
   原来的是:

  for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
  {
      ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[i];
  }   

  应该改成:
  for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
  {
      ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[uiRcMoveIndex+i];
  }   

  由于本连载技术**在各大论坛发布和被转载,我没法做到处处提醒,不得不专门用一节内容来告知各位读者。

  下节预告-----关中断和开中断在多进程临界点的应用。

(未完待续,下节更精彩,不要走开哦)

使用特权

评论回复
433
B40614061| | 2014-7-21 10:08 | 只看该作者
厉害厉害,佩服佩服

使用特权

评论回复
434
chungcountryman| | 2014-7-21 10:55 | 只看该作者
分享贴 必须顶

使用特权

评论回复
435
xg3469| | 2014-7-24 08:41 | 只看该作者
学习了,要好好学习。

使用特权

评论回复
436
jianhong_wu|  楼主 | 2014-7-26 10:35 | 只看该作者
第六十节:用关中断和互斥量来保护多线程共享的全局变量。

开场白:
在前面一些章节中,我提到为了防止中断函数把某些共享数据破坏,在主函数中更改某个数据变量时,应该先关闭中断,修改完后再打开中断;我也提到了网友“红金龙吸味”关于原子锁的建议。经过这段时间的思考和总结,我发现不管是关中断开中断,还是原子锁,其实本质上都是程序在多进程中临界点的数据处理,原子锁有个专用名词叫互斥量,而我引以为豪的状态机程序框架,主函数的switch语句,外加一个定时中断,本质上就是2个独立进程在不断切换并行运行。
为什么要保护多线程共享的全局变量?因为,多个线程同时访问同一个全局变量,如果都是读取操作,则不会出现问题。如果一个线程负责改变此变量的值,而其他线程负责同时读取变量内容,则不能保证读取到的数据是经过写线程修改后的。
这一节要教大家一个知识点:如何用关中断和互斥量来保护多线程共享的全局变量。

具体内容,请看源代码讲解。

(1)硬件平台:
基于朱兆祺51单片机学习板。

(2)实现功能:
在第5节的基础上略作修改,让蜂鸣器在前面3秒发生一次短叫报警,在后面6秒发生一次长叫报警,如此反复循环。

(3)源代码讲解如下:
#include "REG52.H"


#define const_time_3s 1332   //3秒钟的时间需要的定时中断次数
#define const_time_6s 2664   //6秒钟的时间需要的定时中断次数

#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_voice_long   200  //蜂鸣器长叫的持续时间

void initial_myself();   
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void led_flicker();
void alarm_run();   
void T0_time();  //定时中断函数

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned char ucAlarmStep=0; //报警的步骤变量
unsigned int  uiTimeAlarmCnt=0; //报警统计定时中断次数的延时计数器

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

unsigned char ucLock=0;     //互斥量,俗称原子锁
void main()
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral();
   while(1)  
   {
      alarm_run();   //报警器定时报警
   }

}


/* 注释一:
* 保护多线程共享全局变量的原理:
* 多个线程同时访问同一个全局变量,如果都是读取操作,则不会出现问题。如果一个线程负责改变此变量的值,
* 而其他线程负责同时读取变量内容,则不能保证读取到的数据是经过写线程修改后的。
* 鸿哥的基本程序框架都是两线程为主,一个是main函数线程,一个是定时函数线程。
*/

void alarm_run() //报警器的应用程序
{
  
  switch(ucAlarmStep)
  {
     case 0:

           if(uiTimeAlarmCnt>=const_time_3s) //时间到
           {
/* 注释二:
* 用关中断来保护多线程共享的全局变量:
* 因为uiTimeAlarmCnt和uiVoiceCnt都是unsigned int类型,本质上是由两个字节组成。
* 在C语言中uiTimeAlarmCnt=0和uiVoiceCnt=const_voice_short看似一条指令,
* 实际上经过编译之后它不只一条汇编指令。由于另外一个定时中断线程里也会对这个变量
* 进行判断和操作,如果不禁止定时中断或者采取其它措施,定时函数往往会在主函数还没有
* 结束操作共享变量前就去访问或处理这个共享变量,这就会引起冲突,导致系统运行异常。
*/
              ET0=0;  //禁止定时中断
              uiTimeAlarmCnt=0; //时间计数器清零
              uiVoiceCnt=const_voice_short;  //蜂鸣器短叫
                          ET0=1; //开启允许定时中断
              ucAlarmStep=1; //切换到下一个步骤
           }
           break;
     case 1:
           if(uiTimeAlarmCnt>=const_time_6s) //时间到
           {
/* 注释三:
* 用互斥量来保护多线程共享的全局变量:
* 我觉得,在这种场合,用互斥量比前面用关中断的方法更加好。
* 因为一旦关闭了定时中断,整个中断函数就会在那一刻停止运行了,
* 而加一个互斥量,既能保护全局变量,又能让定时中断函数正常运行,
* 真是一举两得。
*/
                      ucLock=1;  //互斥量加锁。 俗称原子锁
              uiTimeAlarmCnt=0; //时间计数器清零
              uiVoiceCnt=const_voice_long;  //蜂鸣器长叫
                      ucLock=0; //互斥量解锁。  俗称原子锁

              ucAlarmStep=0; //返回到上一个步骤
           }
           break;
  }

}

void T0_time() interrupt 1
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断
  
  if(ucLock==0) //互斥量判断
  {
     if(uiTimeAlarmCnt<0xffff)  //设定这个条件,防止uiTimeAlarmCnt超范围。
     {
         uiTimeAlarmCnt++;  //报警的时间计数器,累加定时中断的次数,
     }

     if(uiVoiceCnt!=0)
     {
         uiVoiceCnt--; //每次进入定时中断都自减1,直到等于零为止。才停止鸣叫
         beep_dr=0;  //蜂鸣器是PNP三极管控制,低电平就开始鸣叫。
     }
     else
     {
         ; //此处多加一个空指令,想维持跟if括号语句的数量对称,都是两条指令。不加也可以。
         beep_dr=1;  //蜂鸣器是PNP三极管控制,高电平就停止鸣叫。
     }
  }

  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;
  TR0=1;  //开中断
}


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself()  //第一区 初始化单片机
{
  beep_dr=1; //用PNP三极管控制蜂鸣器,输出高电平时不叫。

  TMOD=0x01;  //设置定时器0为工作方式1


  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;

}
void initial_peripheral() //第二区 初始化外围
{
  EA=1;     //开总中断
  ET0=1;    //允许定时中断
  TR0=1;    //启动定时中断

}
总结陈词:
从下一节开始我准备用几章节的内容来讲常用的数**算程序。这些程序经常要用在计算器,工控,以及高精度的仪器仪表等领域。C语言的语法中不是已经提供了+,-,*,/这些运算符号吗?为什么还要专门写算法程序?因为那些运算符只能进行简单的运算,一旦数据超过了unsigned long(4个字节)的范围就会出错。而这种大数据算法的程序是什么样的?欲知详情,请听下回分解----大数据的加法运算。

(未完待续,下节更精彩,不要走开哦)

使用特权

评论回复
437
datouyuan| | 2014-7-26 11:17 | 只看该作者
收藏了

使用特权

评论回复
438
hww5408| | 2014-7-28 15:43 | 只看该作者
顶起!

使用特权

评论回复
439
vanshrinkzom| | 2014-7-29 14:29 | 只看该作者
jianhong_wu 发表于 2014-7-13 07:58
CAN我没用过。SPI请参考我的第48节,DS1302时钟芯片就是SPI通讯。I2C请参考我的第46节,AT24C02就是I2C通 ...

我也见过很多其他知识的经验之谈,都说“这些东西不用刻意去记,到了用的时候一下子能查出来”
我也很赞成这个观点。
但是经历过好几次面试笔试,那些面试的人都要求把“本来可以用的时候再查”的知识说出来,弄得好像小学那会老师要求背课文一样。如果你不能说出个详细,他就判断你不及格了。

使用特权

评论回复
440
jianhong_wu|  楼主 | 2014-7-30 00:32 | 只看该作者
vanshrinkzom 发表于 2014-7-29 14:29
我也见过很多其他知识的经验之谈,都说“这些东西不用刻意去记,到了用的时候一下子能查出来”
我也很赞 ...

是的。你说的这种情况在一些公司面试中比较常见,我只能说这种面试方式会错过很多人才。如果是我面试刚毕业的大学生,我首先会问问他自己动手做过哪些作品或者项目,如果能拿出实物的照片或者视频来的,我会优先录取。

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则