编译码

1. 什么是曼彻斯特编译码技术

曼彻斯特编码是一种自同步的编码方式，即时钟同步信号就隐藏在数据波形中。在曼彻斯特编码中，每一位的中间有一跳变，位中间的跳变既作时钟信号，又作数据信号；从高到低跳变表示"1"，从低到高跳变表示"0"。还有一种是差分曼彻斯特编码，每位中间的跳变仅提供时钟定时，而用每位开始时有无跳变表示"0"或"1"，有跳变为"0"，无跳变为"1"。

2. 简易编译码电路怎么实现编码和译码的

编码和译码电路需要数字逻辑运算，常见的逻辑运算是：与门、或门、非门，只要你设计好输入和输出，译码和编码就可以用逻辑运算实现，

3. 调制 解调 编码 译码的关系与区别

调制解调，不同信号转换，数字音频转换，和红灯停绿灯行差不多编码译码，数字信号间的转换，和加密解密差不多

4. 哈夫曼编、译码器

这个是我课程设计弄的，也是哈弗曼编码译码器
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;

typedef struct{
int weight;
int parent,lchild,rchild;
int asc;
}HTNode,*HuffmanTree; //定义赫夫曼存储结构

struct node{
int ASCII;
int n;
};
struct node a[127];
struct node w[127];
//一些全局变量
int count;
HTNode H_T[250];
char ** HC;
char filename[20];

//函数声明
void menu1(); //菜单1
HuffmanTree HeapSort(HuffmanTree HT,int length); //堆排序
void MinHeapify(HuffmanTree HT, int k,int len); //调整成一个小顶堆
void buildMinHeap(HuffmanTree HT,int len); //建一个小顶堆
void swap(HTNode &t1,HTNode &t2); //交换两结构体
void savefile(); //把输入的英文文章保存到文件
void loadfile(); //从文件中读取文章
HuffmanTree CreateHuffman(HuffmanTree &HT,struct node *w,int n); //建立赫夫曼数并存入文件
void BianMa(HuffmanTree HT,int n ); //字符编码
void BianMa_all(HuffmanTree HT,char**HC,char *filename); //整篇文章编码
int loadfile2(); //从文件读入文章
void JieMa(); //解码

//主函数
int main()
{
char s;
while(s!='0')
{
system("cls");
cout<<"\n\n\n";
cout<<"\t\t\t\t赫夫曼编码/译码器"<<endl<<endl<<endl<<endl<<endl;
cout<<"\t\t\t\t 1.编码"<<endl<<endl<<endl<<endl;
cout<<"\t\t\t\t 2.译码"<<endl<<endl<<endl<<endl;
cout<<"\t\t\t\t 0.退出"<<endl<<endl<<endl<<endl;
cout<<"\t请输入0—2进行选择，按回车确认";
cin>>s;
switch(s)
{
case '1': menu1(); break;
case '2':
{
system("cls");
JieMa();
system("pause");
break;
}

}

}
}

//菜单1
void menu1(){
char s;
int i;
int a;
char c;
char fpname[20]="article.txt";
HuffmanTree HT;
while(s!='0'){

system("cls");
cout<<"\n\t\t\t\t编码界面";
cout<<"\n\n\n\t\t\t\t1.输入英文文章"<<endl;
cout<<"\n\n\t\t\t\t2.从文件中读入文章"<<endl;
cout<<"\n\n\t\t\t\t0.返回上一层"<<endl;
cout<<"\n\t请输入0—2进行选择，按回车确认";
cin>>s;
switch(s){
case'1':
system("cls");
savefile();
loadfile();
CreateHuffman(HT,w,count);
BianMa(HT,count);
BianMa_all(HT,HC,fpname);
system("cls");
cout<<"出现字符种类共计：";
cout<<count<<endl;
for(i=1;i<=count;i++)
{ a=HT[i].asc;
c=(char)a;

cout<<"________________________________________________________________________________"<<endl;
cout<<"\t\t\t字符：";
cout<<c<<endl;
cout<<"\t\t\tASCII码：";
cout<<a<<endl;
cout<<"\t\t\t频数：";
cout<<HT[i].weight<<endl;
cout<<"\t\t\t赫夫曼编码：";
cout<<HC[i]<<endl;

}
cout<<"________________________________________________________________________________";
cout<<"\n\t\t整篇文章的编码已存入文件“赫夫曼编码.txt”"<<endl;

system("pause");
break;

case'2':
system("cls");
if(loadfile2())
{ system("pause");
return;}
CreateHuffman(HT,w,count);
BianMa(HT,count);
BianMa_all(HT,HC,filename);
system("cls");
cout<<"出现字符种类共计：";
cout<<count<<endl;
for(i=1;i<=count;i++)
{ a=HT[i].asc;
c=(char)a;

cout<<"________________________________________________________________________________"<<endl;
cout<<"\t\t\t字符：";
cout<<c<<endl;
cout<<"\t\t\tASCII码：";
cout<<a<<endl;
cout<<"\t\t\t频数：";
cout<<HT[i].weight<<endl;
cout<<"\t\t\t赫夫曼编码：";
cout<<HC[i]<<endl;

}
cout<<"________________________________________________________________________________";
cout<<"\n\t\t整篇文章的编码已存入文件“赫夫曼编码.txt”"<<endl;
system("pause");
break;
}

}

}

//交换结构体
void swap(HTNode &t1,HTNode &t2)
{
HTNode m;

m = t1;
t1 = t2;
t2 = m;
}

//从键盘输入文章并保存
void savefile(){

FILE *fp;
char article;
if((fp=fopen("article.txt","w"))==NULL){

printf("打开文件不成功！");
exit(0);
}
cout<<"请输入英文文章,以#结束:";
getchar();
article=getchar();
while(article!='#'){

fputc(article,fp);

article=getchar();
}
fclose(fp);
}

//从文件读取文章，并统计字符出现频数
void loadfile(){

FILE *fp;
char ch;
int i,k,j=0;
count=0;
for(i=0;i<=127;i++) //把所有字符的ascii码存在数组
{ a[i].ASCII=i;
a[i].n=0;

}
if((fp=fopen("article.txt","r"))==NULL){

printf("打开文件不成功！");
exit(0);
}
ch=fgetc(fp);
k=(int)ch;
a[k].n++;
while(!feof(fp)){
ch=fgetc(fp);
k=(int)ch;
a[k].n++;
}
fclose(fp);

for(i=0;i<=127;i++) //统计字符种类总数
{
ch=(char)i;
if(a[i].n){
count++;
}
}
for(i=0;i<=127;i++)
{
for(;j<count;)
{
if(a[i].n)
{
w[j].n=a[i].n;
w[j].ASCII=a[i].ASCII;
j++;
break;
}
else break;
}
}

}

//调整为小顶堆
void MinHeapify(HuffmanTree HT, int k,int len)
{
int left=k*2;
int right=k*2+1;
int large;
int l=len;

large = k;
if (left<=l&&HT[left].weight<HT[large].weight)
large = left;

if (right<=l&& HT[right].weight<HT[large].weight)
large=right;

if (large!=k)
{
swap(HT[k],HT[large]);
MinHeapify(HT,large,l);
}
}

//建立小顶堆
void buildMinHeap(HuffmanTree HT,int len)
{
int i;
for (i=len/2;i>=1;i--)
{
MinHeapify(HT,i,len);
}
}

//堆排序
HuffmanTree HeapSort(HuffmanTree HT,int length)
{
int i;
int l=length;
buildMinHeap(HT,length);
for (i=length;i>= 2;i--)
{
swap(HT[1],HT[i]);
length--;
MinHeapify(HT,1,length);
}

return HT;
}

//建立赫夫曼数
HuffmanTree CreateHuffman(HuffmanTree &HT,struct node *w,int n)
{
int i,m,s1,s2,k1,k2,j,x,a;
FILE *fp,*fp2;

if(n<=1) return HT;
m=2*n-1;
HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0不用

for(i=1,j=0;i<=n;i++,j++)
{ HT[i].asc=w[j].ASCII;
HT[i].weight=w[j].n;
HT[i].parent=0;
HT[i].lchild=0;
HT[i].rchild=0;
}
for(;i<=m;i++)
{ a=250+i;
HT[i].asc=a;//父亲节点的asc可以是大于127的任意值
HT[i].weight=0;
HT[i].parent=0;
HT[i].lchild=0;
HT[i].rchild=0;
}
for(i=1;i<=n;i++){

H_T[i].asc=HT[i].asc;
H_T[i].parent=HT[i].parent;
H_T[i].lchild=HT[i].lchild;
H_T[i].rchild=HT[i].rchild;
H_T[i].weight=HT[i].weight;
}

for(i=n+1,x=n;i<=m;i++,x--)
{

HeapSort(H_T,x);
k1=H_T[x].asc;
k2=H_T[x-1].asc;
for(j=1;j<=127;j++)
{
if(HT[j].asc==k1)

}

for(j=1;j<=127;j++)
{
if(HT[j].asc==k2)

}

HT[s2].parent=i;
HT[s1].parent=i;
HT[i].lchild=s1;
HT[i].rchild=s2;
HT[i].weight=HT[s1].weight+HT[s2].weight;

H_T[x-1].asc=HT[i].asc;
H_T[x-1].lchild=HT[i].lchild;
H_T[x-1].parent=HT[i].parent;
H_T[x-1].rchild=HT[i].rchild;
H_T[x-1].weight=HT[i].weight;

}
if((fp2=fopen("count.txt","w"))==NULL) //保存赫夫曼树
{
cout<<"文件打开不成功！"<<endl;
exit(0);
}
fputc(count,fp2);
if((fp=fopen("HuffmanTree.dat","wb"))==NULL)
{ cout<<"文件打开不成功！"<<endl;
exit(0);

}

for(i=1;i<=(2*count-1);i++){
fwrite(&HT[i],sizeof(HTNode),1,fp);
}
fclose(fp);
fclose(fp2);
return HT;

}

//逆向编码
void BianMa(HuffmanTree HT,int n){
char *cd,temp;

int c,f,i,j,len,p,q;

cd=(char *)malloc(n*sizeof(char));
HC=(char * *)malloc(n*sizeof(char*));
for(i=1;i<=n;i++){
for(c=i,f=HT[i].parent,j=0;f!=0;c=f,f=HT[f].parent,j++)
{ if(HT[f].lchild==c) cd[j]='0';
else cd[j]='1';
if(HT[f].parent==0)
cd[j+1]='\0';

}

len=strlen(cd);
for(p=0,q=len-1;p<=q;p++,q--)
{
temp=cd[q];
cd[q]=cd[p];
cd[p]=temp;
}
cd[len]='\0';
HC[i]=(char*)malloc((len+10)*sizeof(char));
strcpy(HC[i],cd);

}

}

//整篇文章编码，并存入文件
void BianMa_all(HuffmanTree HT,char**HC,char *filename){
char ch;
int k,i;
FILE *fp,*fp2;

char code[100];
if((fp=fopen(filename,"r"))==NULL){

printf("打开文件不成功！");
exit(0);
}
if((fp2=fopen("赫夫曼编码.txt","w"))==NULL){

printf("打开文件不成功！");
exit(0);
}
ch=fgetc(fp);
k=(int)ch;
while(!feof(fp))
{

for(i=1;i<=count;i++)
{
if(k==HT[i].asc)
strcpy(code,HC[i]);

}
fputs(code,fp2);
ch=fgetc(fp);
k=(int)ch;

}
fclose(fp);
fclose(fp2);

}

void JieMa(){
int i,k,a,t,n=0;
FILE *fp1,*fp2,*fp3;
char ch,c;
HuffmanTree ht;
if((fp3=fopen("count.txt","r"))==NULL) //从文件读出字符总数
{
printf("打开文件不成功！");
exit(0);
}
n=fgetc(fp3);
ht=(HuffmanTree)malloc(2*n*sizeof(HTNode));
if((fp1=fopen("赫夫曼编码.txt","r"))==NULL)
{

printf("打开文件不成功！");
exit(0);
}

if((fp2=fopen("HuffmanTree.dat","rb"))==NULL)
{ cout<<"文件打开不成功！"<<endl;
exit(0);

}
for(i=1;i<=2*n-1;i++)

fread(&ht[i],sizeof(HTNode),1,fp2);

for(i=1;i<=2*n-1;i++)
{
if(ht[i].parent==0)
}

ch=fgetc(fp1);
while(!feof(fp1)){
if(ch=='0')
{
k=ht[k].lchild;
if(ht[k].lchild==0)
{a=ht[k].asc;
c=(char)a;
printf("%c",c);;

k=t;
}
}
if(ch=='1')
{
k=ht[k].rchild;
if(ht[k].lchild==0)
{ a=ht[k].asc;
c=(char)a;
printf("%c",c);

k=t;
}

}

ch=fgetc(fp1);
}
fclose(fp1);
fclose(fp2);

}

//读取文件中的文章，可自己选择文件
int loadfile2(){

FILE *fp;
char ch;
int i,k,j=0;
count=0;
for(i=0;i<=127;i++)
{ a[i].ASCII=i;
a[i].n=0;

}
cout<<"\n\n\n\t\t\t请输入你要打开的文件名：";
cin>>filename;
if((fp=fopen(filename,"r"))==NULL){

printf("打开文件不成功！");
return 1;
}
ch=fgetc(fp);
k=(int)ch;
a[k].n++;
while(!feof(fp)){
ch=fgetc(fp);
k=(int)ch;
a[k].n++;
}
fclose(fp);

for(i=0;i<=127;i++){
ch=(char)i;
if(a[i].n){
count++;
}
}
for(i=0;i<=127;i++)
{
for(;j<count;)
{
if(a[i].n)
{
w[j].n=a[i].n;
w[j].ASCII=a[i].ASCII;
j++;
break;
}
else break;
}
}
return 0;
}

5. 计算机编译就是指编码和译码两个过程吗

在微指令的控制字段中,每一位代表一个微命令,在设计微指令时,是否发出某个微命令,只要将控制字段中相应位置成"1"或"0",这样就可打开或关闭某个控制门,这就是直接控制法.
在6.3节中所讲的就是这种方法.但在某些复杂的计算机中,微命令甚至可多达三四百个,这使微指令字长达到难以接受的地步,并要求机器有大容量控制存储器,为了改进设计出现了以下各种编译法.
6.4.1 微指令的编译法(编码译码方法)(2)
2.字段直接编译法
在计算机中的各个控制门,在任一微周期内,不可能同时被打开,而且大部分是关闭的(相应的控制位为"0").所谓微周期,指的是一条微指令所需的执行时间.如果有若干个(一组)微命令,在每次选择使用它们的微周期内,只有一个微命令起作用,那么这若干个微命令是互斥的.
例如,向主存储器发出的读命令和写命令是互斥的;又如在ALU部件中,送往ALU两个输入端的数据来源往往不是唯一的,而每个输入端在任一微周期中只能输入一个数据,因此控制该输人门的微命令是互斥的.
选出互斥的微命令,并将这些微命令编成一组,成为微指令字的一个字段,用二进制编码来表示, 就是字段直接编译法.
6.4.1 微指令的编译法(编码译码方法)(3)
例如,将7个互斥的微命令编成一组,用三位二进制码分别表示每个微命令,那么在微指令中,该字段就从7位减成3位,缩短了微指令长度.而在微指令寄存器的输出端,为该字段增加一个译码器,该译码器的输出即为原来的微命令.
6.4.1 微指令的编译法(编码译码方法)(4)
字段长度与所能表示的微命令数的关系如下:
字段长度 微命令数
2位 2～3
3位 4～7
4位 8～15
一般每个字段要留出一个代码,表示本段不发出任何微命令,因此当字段长度为3位时,最多只能表示7个互斥的微命令,通常代码000表示不发微命令.
6.4.1 微指令的编译法(编码译码方法)(5)
3.字段间接编译法
字段间接编译法是在字段直接编译法的基础上,进一步缩短微指令字长的一种编译法.
如果在字段直接编译法中,还规定一个字段的某些微命令,要兼由另一字段中的某些微命令来解释,称为字段间接编译法.
本方法进一步减少了指令长度,但很可能会削弱微指令的并行控制能力,因此通常只作为直接编译法的一种辅助手段.
6.4.1 微指令的编译法(编码译码方法)(6)
字段A(3位)的微命令还受字段B控制,当字段B发出b1微命令时,字段A发出a1,1,a1,2,…,a1,7中的一个微命令;而当字段B发出b2微命令时,字段A发出a2,1,a2,2,…,a2,7中的一个微命令,仅当A为000时例外,此时什么控制命令都不产生.
6.4.1 微指令的编译法(编码译码方法)(7)
4.常数源字段E
在微指令中,一般设有一个常数源字段E就如指令中的直接操作数一样.E字段一般仅有几位,用来给某些部件发送常数,故有时称为发射字段.
该常数有时作为操作数送入ALU运算;有时作为计算器初值,用来控制微程序的循环次数等.
6.4.2 微程序流的控制 (1)
当前正在执行的微指令,称为现行微指令,现行微指令所在的控制存储器单元的地址称现行微地址,现行微指令执行完毕后,下一条要执行的微指令称为后继微指令,后继微指令所在的控存单元地址称为后继微地址.
所谓微程序流的控制是指当前微指令执行完毕后,怎样控制产生后继微指令的微地址.
与程序设计相似,在微程序设计中除了顺序执行微程序外还存在转移功能和微循环程和微子程序等,这将影响下址的形成.
下面介绍几种常见的产生后继微指令地址的方法.
6.4.2 微程序流的控制 (2)
(1)以增量方式产生后继微地址.
在顺序执行微指令时,后继微地址由现行微地址加上一个增量(通常为1)形成的;而在非顺序执行时则要产生一个转移微地址.
机器加电后执行的第一条微指令地址(微程序入口)来自专门的硬件电路,控制实现取令操作,然后由指令操作码产生后继微地址.接下去,若顺序执行微指令,则将现行微地址主微程序计数器( PC中)+1产生后继微地址;若遇到转移类微指令,则由 PC与形成转移微地址的逻辑电路组合成后继微地址.
6.4.2 微程序流的控制 (3)
6.4.2 微程序流的控制 (4)
(2)增量与下址字段结合产生后继微地址
将微指令的下址字段分成两部分:转移控制字段BCF和转移地址字段BAF,当微程序实现转移时,将BAF送 PC,否则顺序执行下一条微指令( PC+1).
执行微程序条件转移时,决定转移与否的硬件条件有好几种.例如,"运算结果为零","溢出","已完成指定的循环次数"等.
我们假设有八种转移情况,定义了八个微命令(BCF取3位),在图中设置计数器CT用来控制循环次数.如在执行乘(或除)法指令时,经常采用循环执行"加,移位"(或减,移位)的方法,指令开始执行时,在CT中置循环次数)每执行一次循环,计数器减1,当计数器为零时结束循环.又考虑到执行微子程序时,要保留返回微地址,因此图中设置了一个返回寄存器RR.

6. MATLAB： 数字通信系统信道编码 AMI 编译码

程序如下，现在原始序列长度20的随机0，1串，要变自己改。
clc;
clear;
source = randint(1,20);
%%%%%%%%%%%% Encode %%%%%%%%%%%%%
perbit = -1;
for i=1:length(source);
if source(i)==1
encoded(i) = (-1)*perbit;
perbit = encoded(i);
else
encoded(i) = source(i);
end
end
%%%%%%%%%%%% Decode %%%%%%%%%%%%
for i=1:length(source);
if encoded(i)~=0
decoded(i) = 1;
else
encoded(i) = 0;
end
end

source
encoded
decoded

7. 编译码电路MC145026/MC145027实现的是什么功能请内行朋友告诉一下，谢谢！

此组芯片是摩托罗拉公司生产的用于通信配对使用的最新芯片。编码芯片MC145026可对9位输入信息（地址位A1～A5，数据位D6～D9）进行编码，编码后每个数据位用两个脉冲表示：“1”编码为两个宽脉冲；“0”编码为两个窄脉冲；“开路”编码为一宽脉冲和一窄脉冲交叉。当TE端输入脉冲上升沿时，编码后的数据流开始由D0串行输出。对于每9位数据信息，能看作是个数据字，为了提高通信的安全性，编解码芯片对每个数据字发送两次，接收两次。

MC145027解码器用于接收MC145026输出的编码数据流。当解码器地址和编码器地址状态相并连续收到两组相同编码信号时，VT端由低电平跳变为高电平以指示接收有效，同时中断计算机进行接收。
简单的说，就是用来编码地址，识别地址。配对用的。

8. 单片机串口通信编译码

串口直接丢过去收到就是了，为啥还要编码译码？加密么

9. PCM编译码系统由哪些部分构成各部分的作用是什么

PCM
编译码系统由哪些部分构成
?
各部分的作用是什么
?

回答：

其中，低通滤波器：把话音信号带宽限制为
3.4KHz
，把高于这个频率的信号过滤掉。

抽样：
对模拟信号以其信号带宽
2
倍以上的频率进行周期性的扫描，
把时间上连续的信号变
成时间上离散的信号。

量化：把经抽样得到的瞬时值进行幅度离散化，即指定
M
个规定的电平，把抽样值用最接
近的电平标示。

编码：用二进制码组表示有固定电平的量化值。

译码：与编码器的作用相反，把收到的
PCM
信号还原成相应的
PAM
信号，实现数模变换