avant-propos

Après avoir appris le codage et le codage, l'enseignant du cours a déclaré que le codage pouvait être implémenté avec du code et souhaitait utiliser une expérience pour nous permettre de le faire. Cependant, les cours expérimentaux pour les étudiants de cette année sont limités, nous ne pouvons donc l'organiser qu'à partir du prochaine classe d'élèves. Ces jours-ci, la fête nationale est en vacances, et je n'ai rien à faire, j'ai donc programmé un encodeur de comparaison séquentielle en langage C , et je devrais revoir le langage C. Ma capacité de codage est limitée. Si vous apprenez ces connaissances, j'espère que cet article vous sera utile.

Astuce : Ce qui suit est le texte de cet article, qui sont tous originaux par l'auteur lui-même. Il n'est pas facile d'écrire un article. J'espère que vous joindrez un lien vers cet article lors de la publication.

1. Connaissance de base du codage

Le codage est divisé en quantification non uniforme et quantification uniforme. En prenant l'intervalle de quantification minimum Δ=1/2048 pendant la quantification non uniforme comme l'intervalle de quantification de la quantification uniforme, il y a 2048 niveaux de quantification uniformes du premier segment au huitième segment de la ligne 13 fois, et la quantification non uniforme Là sont seulement 128 niveaux de quantification.

La quantification uniforme doit encoder des codes 11 bits, tandis que la quantification non uniforme n'a besoin que d'encoder des codes 7 bits. Le codage selon des caractéristiques de quantification non uniformes est généralement appelé codage non linéaire ; le codage selon des caractéristiques de quantification uniformes est appelé codage linéaire.

A condition d'assurer le même intervalle de quantification pour les petits signaux, le codage non linéaire 7 bits est équivalent au codage linéaire 11 bits

Le niveau de démarrage et l'intervalle de quantification sont indiqués dans la figure ci-dessous :

La transformation 7/11 est illustrée dans la figure ci-dessous :

La transformation 7/12 est illustrée dans la figure ci-dessous :

2. Encodeur de comparaison successive

Processus de codage de la méthode de comparaison successive

Déterminez la polarité de la valeur d'échantillon x et compilez un 1 ;

Prenez la valeur absolue de x | x |, et jugez le code de numéro de segment a 2, a 3, a 4 en trois fois ;

Calculez le niveau intra-segment et compilez les codes intra-segment a 5, a 6, a 7 et a 8 en quatre temps.

Le processus de calcul est illustré dans la figure ci-dessous :

Certaines relations entre les codes de paragraphe et les codes intra-paragraphe sont illustrées dans la figure suivante :

3. Code de programmation

Code 1.C

code afficher comme ci-dessous:

//school:  cq university
//student: clg
//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;
    
}

2. Résultats des simulations

Le résultat de l'exécution du code est illustré dans la figure ci-dessous :

Résumer

C'est ce dont je vais parler aujourd'hui.Cet article présente les connaissances de base du codage et comment utiliser la programmation en langage C pour réaliser l'encodeur de comparaison successif et la conversion 7/11, 7/12.

Encodage PCM du principe de communication et implémentation en langage C de l'encodeur à comparaisons successives