通信原理之PCM编码及C语言实现逐次比较型编码器

迎风打盹儿

已于 2025-03-08 12:56:31 修改

阅读量4.7k

点赞数 3

分类专栏：数字通信原理文章标签： c语言 vscode 编码器通信原理逐次比较

于 2022-10-03 12:41:44 首次发布

本文链接：https://blog.csdn.net/m0_66360845/article/details/127150753

版权

数字通信原理专栏收录该内容

10 篇文章

订阅专栏

逐次比较型编码器及各种转换

前言

学了编译码之后，课程老师说编码可以用代码实现，还想用一次实验让我们来编一下，但本届学生实验课有限，只能从下一届的学生开始安排了。这些天国庆放假，闲来无事儿，就用C语言编了个逐次比较型编码器，就当复习一下C语言了。本人码字能力有限，各位如果正在学该知识，希望这篇文章对各位有所帮助。

提示：以下是本篇文章正文内容，均为作者本人原创，写文章实属不易，希望各位在转载时附上本文链接。

一、编码基本知识

编码分为非均匀量化与均匀量化。以非均匀量化时的最小量化间隔Δ=1/2048作为均匀量化的量化间隔，从13折线的第一段到第八段所包含的均匀量化级数共有2048个均匀量化级，而非均匀量化只有128量化级。

均匀量化需要编11位码，而非均匀量化只要编7位码。通常把按非均匀量化特性的编码称为非线性编码；按均匀量化特性的编码称为线性编码。

在保证小信号时的量化间隔相同的条件下，7 位非线性编码与11 位线性编码等效

起始电平和量化间隔如下图所示：

7/11变换如下图所示：

7/12变换如下图所示：

二、逐次比较型编码器

逐次比较法编码流程

判别样值x的极性，编出a1;

取x的绝对值|x|，分三次判断段号代码a2,a3,a4;

计算段内电平，分四次编出段内码a5,a6,a7,a8。

计算流程如下图所示：

段落码、段内码的一些关系如下图所示：

三、编程代码

1.C代码

代码如下：

//school:  cq university
//student: 
//create time:2022/10/03
#include<stdio.h>
#include<math.h>
int main()
{
    printf("请输入信号抽样值(-2048——+2048之间的整数):");
    int a,b;
    int encoder[8]={0};           //待输出8位编码结果并初始化为0
    int code[11]={0};             //7/11变换
    int coder[12]={0};            //7/12变换
    int start_level[8]={0,16,32,64,128,256,512,1024};      //8段起始量化电平
    int quantization_space[8]={1,1,2,4,8,16,32,64};  //8个量化间距
    scanf("%d",&a);
    if (a<0)
        encoder[0]=0;
    if (a>0)
        encoder[0]=1;
    a=abs(a);
    if (a>=start_level[4])
    {   
        encoder[1]=1;
        if (a>=start_level[6])
        {
            encoder[2]=1;
            if (a>=start_level[7])
            {
                encoder[3]=1;
            }
            else
                encoder[3]=0;
        }
        else
        {
            encoder[2]=0;
            if(a>=start_level[5])
                {
                    encoder[3]=1;
                }
            else
                {
                    encoder[3]=0;
                }
        }
    }    
    else
    {
        encoder[1]=0;
        if (a>=start_level[2])
        {
            encoder[2]=1;
            if (a>=start_level[3])
            {
                encoder[3]=1;
            }
            else
                encoder[3]=0;
        }
        else
        {
            encoder[2]=0;
            if(a>=start_level[1])
                {
                    encoder[3]=1;
                }
            else
                {
                    encoder[3]=0;
                }
        }
    }
    b=encoder[1]*4+encoder[2]*2+encoder[3]*1;
    if( a>=(start_level[b]+quantization_space[b]*8) )
        encoder[4]=1;
    else
        encoder[4]=0;
    if( a>=(start_level[b]+encoder[4]*quantization_space[b]*8+quantization_space[b]*4) )
        encoder[5]=1;
    else
        encoder[5]=0;
    if( a>=(start_level[b]+encoder[4]*quantization_space[b]*8+encoder[5]*quantization_space[b]*4+quantization_space[b]*2) )
        encoder[6]=1;
    else
        encoder[6]=0;
    if( a>=(start_level[b]+encoder[4]*quantization_space[b]*8+encoder[5]*quantization_space[b]*4+encoder[6]*quantization_space[b]*2+quantization_space[b]) )
        encoder[7]=1;
    else
        encoder[7]=0;
    if( (encoder[1]*4+encoder[2]*2+encoder[3]*1)==0 )        //7/11变换
        {
            code[7]=encoder[4];
            code[8]=encoder[5];
            code[9]=encoder[6];
            code[10]=encoder[7];
        }
    else
        {
            code[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)]=1;
            code[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+1]=encoder[4];
            code[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+2]=encoder[5];
            code[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+3]=encoder[6];
            code[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+4]=encoder[7];
        }
    if( (encoder[1]*4+encoder[2]*2+encoder[3]*1)==0 )     //7/12变换
        {
            coder[7]=encoder[4];
            coder[8]=encoder[5];
            coder[9]=encoder[6];
            coder[10]=encoder[7];
            coder[11]=1;
        }
    else
        {
            coder[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)]=1;
            coder[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+1]=encoder[4];
            coder[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+2]=encoder[5];
            coder[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+3]=encoder[6];
            coder[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+4]=encoder[7];
            coder[7-(encoder[1]*4+encoder[2]*2+encoder[3]*1)+5]=1;
        }
    printf("该量化电平位于第%d段\n",encoder[1]*4+encoder[2]*2+encoder[3]*1+1);
    printf("第%d段的量化间距为:%d\n",encoder[1]*4+encoder[2]*2+encoder[3]*1+1,quantization_space[b]);
    printf("第%d段的起始电平为:%d\n",encoder[1]*4+encoder[2]*2+encoder[3]*1+1,start_level[encoder[1]*4+encoder[2]*2+encoder[3]*1]);
    printf("量化误差为:%d\n",a-(start_level[b]+encoder[4]*quantization_space[b]*8+encoder[5]*quantization_space[b]*4+encoder[6]*quantization_space[b]*2+encoder[7]*quantization_space[b]));
    printf("8位编码结果:%d%d%d%d%d%d%d%d\n",encoder[0],encoder[1],encoder[2],encoder[3],encoder[4],encoder[5],encoder[6],encoder[7]);
    printf("7位编码结果(不加极性位):%d%d%d%d%d%d%d\n",encoder[1],encoder[2],encoder[3],encoder[4],encoder[5],encoder[6],encoder[7]);
    printf("7/11转换结果:%d%d%d%d%d%d%d%d%d%d%d\n",code[0],code[1],code[2],code[3],code[4],code[5],code[6],code[7],code[8],code[9],code[10]);
    printf("7/12转换结果(非线性码转线性码):%d%d%d%d%d%d%d%d%d%d%d%d\n",coder[0],coder[1],coder[2],coder[3],coder[4],coder[5],coder[6],coder[7],coder[8],coder[9],coder[10],coder[11]);
    return 0;
    
}