《数字通信原理的13折线u律法》算法的程序编写

 

            今天，为了加深自己对数字通信原理编码技术的理解，特别在VC++的环境下编写了基于《数字通信原理的13折线u律法》算法的程序！

            压缩扩张技术：压缩大信号，放大小信号！其中由u律和A律，我国使用A律！！！呵呵！其中，关于13折线编码规律，可以百度，偶在这就不做详细介绍了！！！！下面向大家分享一下自己花了大半天的成果，由于本人对这个编码的思想还不是很了解，其中的遍历算法处，编码可能有点纰漏，希望大家批评指出！

                                                   座右铭：求知若渴，虚心若愚！

//=================================================================================================================

//源代码，由于纯C编程，可以很方便地移植到51或者其他系列的单片机

 

/*===========================================================
  
                       基于《数字通信原理技术的13折线u律算法》
   
                                       PROGRAM BY  AC
 
         PROFESSIONAL: Electronic and information engineering

                                   

                                     DATE:2011-06-28
  
                                  ALL RIGHTS RESEVED!

=============================================================*/

#include<stdio.h>
#include<math.h>
typedef int uchar;
uchar Duan_Luo[]={1,2,3,4,5,6,7,8};                                       //段落
uchar Duan_level[]={0,16,32,64,128,256,512,1024};             //段落起始电平
uchar Liang_Hua_Jiange[]={1,1,2,4,8,16,32,64};                    //量化间隔
uchar a0=0,a1=0,a2=0,a3=0,a4=0,a5=0,a6=0,a7=0;              //编码后的8位码组a0-a7

uchar Value_Process_Main(signed int);                                  //处理量化值并找出所在主段
                                                                                                //处理量化值并找出所在次段
uchar Value_Process_Little(signed int dat,uchar level,uchar jiange);   

void main(void)
{
 uchar Mduan,Lduan;                                                               //主段和次段
 signed int data;                                                                       //量化值
 printf("请输入要量化的值:");
 //debug,+690,可测试结果为主段7,次段6,码组:11100101
 scanf("%d",&data);
 printf("需要量化的值为：%d\n",data);
 Mduan=Value_Process_Main(data);
 printf("a0=%d,a1=%d,a2=%d,a3=%d\n",a0,a1,a2,a3);
 printf("主段在第%d段中!\n",Mduan);
 //Lduan=Value_Process_Little(data,512,32);  //debug
 switch(Mduan)
 {
  case 8:Lduan=Value_Process_Little(data,Duan_level[7],Liang_Hua_Jiange[7]);break;
  case 7:Lduan=Value_Process_Little(data,Duan_level[6],Liang_Hua_Jiange[6]);break;
  case 6:Lduan=Value_Process_Little(data,Duan_level[5],Liang_Hua_Jiange[5]);break;
  case 5:Lduan=Value_Process_Little(data,Duan_level[4],Liang_Hua_Jiange[4]);break;
  case 4:Lduan=Value_Process_Little(data,Duan_level[3],Liang_Hua_Jiange[3]);break;
  case 3:Lduan=Value_Process_Little(data,Duan_level[2],Liang_Hua_Jiange[2]);break;
  case 2:Lduan=Value_Process_Little(data,Duan_level[1],Liang_Hua_Jiange[1]);break;
  case 1:Lduan=Value_Process_Little(data,Duan_level[0],Liang_Hua_Jiange[0]);break;
  default:printf("主段不存在!!!请检查数据输入是否正确!\n"); 
 }
 printf("次段处于第%d小段中!\n",Lduan);
 printf("a4=%d,a5=%d,a6=%d,a7=%d\n",a4,a5,a6,a7);
 printf("编码后的码组为a0-a7:%d%d%d%d%d%d%d%d\n",a0,a1,a2,a3,a4,a5,a6,a7);

}

uchar Value_Process_Main(signed int dat)
{
 uchar datt=0,i,flag=0;
 if(dat>0) a0=1;
 datt=abs(dat);
 if(datt>2048)
 {
  printf("Invalid data>2048!!!\n");
  return 0;
 }
    for(i=0;i<8;i++)                                  //值刚好在段中"=="
    {
 
  if(datt==Duan_level[i])                       //遍历的所查得的数据编码处理
  {
   switch(i+1)                                        //这里的编码可能有误，没时间去理解编码原理
            {
    case 8:a1=1;a2=1;a3=1;break;        //用空再修改此处
    case 7:a1=1;a2=1;a3=0;break;
    case 6:a1=1;a2=0;a3=1;break;
    case 5:a1=1;a2=0;a3=0;break;
    case 4:a1=0;a2=1;a3=1;break;
    case 3:a1=0;a2=1;a3=0;break;
    case 2:a1=0;a2=0;a3=1;break;
    case 1:a1=0;a2=0;a3=0;break;
   }
   return (i+1);
  } 
 }   
    if(datt>Duan_level[4])               //值在段5-8段中">128"
 {
  flag=1;
     a1=1;
 }
    else                                        //值在段1-4段中"<128"
 {
  flag=0;
  a1=0;
 }
 if(flag==1)                                //处理5-8段数据
 {
  flag=0;
  if(datt>Duan_level[6])            //值大于512,在7-8段
        {
   flag=1;
   a2=1;
  }
  else          //小于512，在5-6段
  {
   flag=0;
   a2=0;
  }
  if(flag==1)                                  //处理7-8段数据
  {
   flag=0;
   if(datt>=Duan_level[7])             //>1024，表示在第八段
   {
    a3=1;
    return 8;
   }
   else                                         //<1024,表示在第七段
   {
    a3=0;
    return 7;
   } 
  }
  else                                          //处理5-6段数据
  {
   if(datt>Duan_level[5])             //">256",在第六段
   {
    a3=1;
    return 6;
   }
   else
   {
    a3=0;
    return 5;
   }
  }
 }
 else                                        //处理1-4段数据
    {
  if(datt>Duan_level[2])          //值大于32,在3-4段
        {
   flag=1;
   a2=1;
  }
  else                                    //小于32，在1-2段
  {
   flag=0;
   a2=0;
  }
  if(flag==1)                         //处理3-4段数据
  {
   flag=0;
   if(datt>Duan_level[3])     //>64，表示在第4段
   {
    a3=1;
    return 4;
   }
   else                               //<64,表示在第3段
   {
    a3=0;
    return 3;
   } 
  }
  else                               //处理1-2段数据
  {
   if(datt>Duan_level[1])   //">16",在第2段
   {
    a3=1;
    return 2;
   }
   else                              //"<16",在第1段
   {
    a3=0;
    return 1;
   }

  }
  
 }

}

uchar Value_Process_Little(signed int dat,uchar level,uchar jiange)
{
 uchar i=0,flag=0,flag1=0,datt;
 uchar temp[8*2];                     //每主段分为16小段
 datt=abs(dat);
    for(i=0;i<16;i++)                  //遍历数据，直接查出段
 {
  temp[i]=level+jiange*(i+1);
 }
    for(i=0;i<16;i++)                    //遍历的数据编码处理
 {
  if(datt==temp[i])                      //这里的编码可能有误
  {
   switch(i+1)                             //没时间去理解编码原理，以后再弄
   {
    
    case 16:a4=1;a5=1;a6=1;a7=1;break;
    case 15:a4=1;a5=1;a6=1;a7=0;break;
    case 14:a4=1;a5=1;a6=0;a7=1;break;
    case 13:a4=1;a5=1;a6=0;a7=0;break;
    case 12:a4=1;a5=0;a6=1;a7=1;break;
    case 11:a4=1;a5=0;a6=2;a7=0;break;
    case 10:a4=1;a5=0;a6=0;a7=1;break;
    case 9:a4=1;a5=0;a6=0;a7=0;break;
    case 8:a4=0;a5=1;a6=1;a7=1;break;
    case 7:a4=0;a5=1;a6=1;a7=0;break;
    case 6:a4=0;a5=1;a6=0;a7=1;break;
    case 5:a4=0;a5=1;a6=0;a7=0;break;
    case 4:a4=0;a5=0;a6=1;a7=1;break;
    case 3:a4=0;a5=0;a6=1;a7=0;break;
    case 2:a4=0;a5=0;a6=0;a7=1;break;
    case 1:a4=0;a5=0;a6=0;a7=0;break;
   
   }
   return (i+1);
  }
 }
 if(datt>temp[7])         //">midle value",在9-16段中 
 {
  flag=1;
  a4=1;
 }
    else                      //"<midle value",在1-8段中
 {
  flag=0;
  a4=0;
 }
    if(flag==1)          //处理9-16小段得数据
    {
  flag=0;
  flag1=1;                //处理高8段得标志
  if(datt>temp[3+8]) //>midle value在13-16段
        {
   flag=1;
      a5=1;
  }
  else                     //<midle value在9-12段
  {
   flag=0;
   a5=0;
  }
 }
 else                 //处理1-8小段得数据
 {
  flag1=0;         //处理高8段得标志
  if(datt>temp[3]) //>midle value在5-8段
        {
   flag=1;
      a5=1;
  }
  else                //<midle value在1-4段
  {
   flag=0;
   a5=0;
  }
 }
   if(flag1==1)  //处理高8段
   {
  if(flag==1)    //处理高高4段
  {
   flag=0;
   if(datt>temp[3+2+8])     //在15-16段
   {
    flag=1;
    a6=1;
   }
   else                              //在13-14段
   {
    flag=0;
    a6=0;
   }
  //判断在那段
   if(flag==1)
   {
    flag=0;
    if(datt>temp[13+1]){a7=1;return 16;}
    else{a7=0;return 15;}
   }
   else
   {
    if(datt>temp[13-1]){a7=1;return 14;}
    else{a7=0;return 13;}
   }
  }
  else                              //处理高低4段
        {
   if(datt>temp[3-2+8])     //在11-12段
   {
    flag=1;
    a6=1;
   }
   else                            //在9-10段
   {
    flag=0;
    a6=0;
   }
        //判断在那段
   if(flag==1)
   {
    flag=0;
    if(datt>temp[9+1]){a7=1;return 12;}
    else{a7=0;return 11;}
   }
   else
   {
    if(datt>temp[9-1]){a7=1;return 10;}
    else{a7=0;return 9;}
   }
  }   
   }
   else                                          //处理低8段
   {
  if(flag==1)                                 //处理低高4段
  {
   flag=0;
   if(datt>temp[3+2])                     //在7-8段
   {
    flag=1;
    a6=1;
   }
   else                                         //在5-6段
   {
    flag=0;
    a6=0;
   }
        //判断在那段
   if(flag==1)
   {
    flag=0;
    if(datt>temp[5+1]){a7=1;return 8;}
    else{a7=0;return 7;}
   }
   else
   {
    if(datt>temp[5-1]){a7=1;return 6;}
    else{a7=0;return 5;}
   }
  }
  else                                //处理低低4段
        {
   if(datt>temp[3-2])          //在3-4段
   {
    flag=1;
    a6=1;
   }
   else                              //在1-2段
   {
    flag=0;
    a6=0;
   }
         //判断在那段
   if(flag==1)
   {
    flag=0;
    if(datt>temp[1+1]){a7=1;return 4;}
    else{a7=0;return 3;}
   }
   else
   {
    if(datt>temp[1-1]){a7=1;return 2;}
    else{a7=0;return 1;}
   }
  }
   }
}

//=================================================================================================================

//源代码结束

              总结：此程序还可以扩展，通过添加计算误差模块算出误差，程序的编写可以根据u律思想来编写，由于明天还要忙，现在也要忙于生活，所以就没写这个误差计算模块，留给大家一起讨论吧，呵呵。由于作者水平有限，加之又是初学者，希望大家看到有啥不对的地方留言给我，偶不吝赐教！！谢谢！！AC！！~~~