精华内容
下载资源
问答
  • 基于MATLAB调制解调与信道编译码仿真教程基于MATLAB调制解调与信道编译码仿真摘要:随着信息时代步伐,通信技术得到了全面发展,信息技术已成为了21世纪最强大国际化动力。在通信技术中,信息调制、解调...

    基于MATLAB的调制解调与信道编译码仿真教程

    基于MATLAB的调制解调与信道编译码仿真摘要:随着信息时代的步伐,通信技术得到了全面的发展,信息技术已成为了21世纪最强大的国际化动力。在通信技术中,信息的调制、解调和误码纠错都占有重要的地位。MATLAB作为一款功能强大的数学工具软件,在通信领域中得到了很广泛的应用。本文基于MATLAB对信号进行模拟仿真设计,实现对二进制相移键控、循环码的纠错仿真、BPSK的调制解调等进行仿真设计。关键字:MATLAB、调制解调、2PSK、BPSK、重复码。

    一 、二进制和四进制相移键控调制仿真设计二进制相移键控(2PSK)原理 相移键控是利用载波的相位变化来传递数字信息的,而振幅和频率保持不变。在2PSK中常用0和π分别表示二进制“0”和“1”,2PSK的信号时域表达式为: 表示为第n个符号的绝对相位,因此上式可改写为: 由于表示信号的两种码形完全相同,极性相反,故2PSK信号一般表示一个双极性全占空矩形脉冲序列与一个正弦载波相乘。=s(t)coswct其中: s(t)=g(t-nTs);这里,g(t)为脉宽Ts的单个矩形脉冲;的统计特征为 =1, & 概率为P-1, & 概率为1-P即发送二进制“0”时(),取0相位;发送二进制符号“1”时(),取π相位。这种以载波的不同相位直接法去表示相应二进制数字信号的调制方式,称为二进制绝对相移方式。

    2PSK信号时间波形2PSK信号的调制原理如下图所示,与2ASK的产生方法相比,只是对s(t)的要求不同,在2ASK中s(t)是单极性的,而在2PSK中s(t)是双极性的基带信号。

    模拟调制方法

    键控法 2PSK信号的解调通常采用相干解调法,解调原理如下原理框图所示,在相干解调中,如何得到与接受的2PSK信号同频同相的相干载是关键问题,后续进一步介绍。

    2PSK信号的调解原理框图 二进制差分相移键控2PSK相干调解时,由于载波恢复中相位有0、π模糊性,导致调解过程出现”反相工作”现象,恢复出的信号“1”和“0”倒置,从而使2PSK难以实际应用。二进制差分相移键控(2DPSK)能够克服次缺点。2DPSK是利用前后码元的载波相位变化传递数字信息,假设?φ为当前码元与前一码元的载波相位差,定义为一种数字信息与?φ之间的关系为 ?φ=0 表示数字信息“0”1 表示数字信息“1”与是可将一组二进制数字信息与其对应的2DPSK信号的载波相位关系示例如下:二进制数字信息: 1 1 0 1 0 0 1 1 02DPSK信号或相位:(0)π 0 0 π π π 0 π π 或 :(π)0 π π 0 0 0 π 0 0相应的2DPSK的典型波形如下图: ?φ=0 表示数字信息“1”π 表示数字信息“0”(a)绝对码 1 1 0 1 0(c)2DPSK(b)相对码 0 1 0 0 1 1 对于相同的基带数字信息序列,由于序列初始码元的参考相位不同,2DPSK信号的位置可以不同。2DPSK信号的相位并不直接代表基带信号,而前后码元相对相位的差才唯一决定信息的符号。 1.3 四进制幅度调制原理振幅键控时利用载波的振幅变化来传递数字信息,而其频率和初始相位保持不变。4ASK信号的一般表达式为e4ASK=nang(t-nTB)cosωct如果其中是0的四进制信号,只要让载波信号与多进制信号通过乘法器即可调制完成。如果两个电平都不是0,只要让载波信号的振幅固定,通过乘法器与多进制信号相乘。

    而解调的两种方法包括非相干解调和相干解调,其原理图如下:

    程序流程图:

    2PSK调制流程图

    二、二进制对称信道下的重复码编译码及错误概率统计仿真设计2.1 循环码的编码循环码是采用循环移位的特性界定的一种线性分组码,除了具有线性分组码的一般特性之外,还具有循环性,是一种无权码。循环码的最大特点就是码字循环特性,所谓循环特性是指循环码中任何一组循环码循环移位后,所得到的码组仍是循环码。若(an-1 an-2 ,,,a1an)为一组循

    展开全文
  • 信息编码采用某种规则或方法编写代码来表示各种信息,为计算机中数据与实际处理信息之间建立联系,提高信息处理效率。在计算机中,各种信息都是以二进制编码形式存在;也就是说,不管是文字、图片、声音、...
  • 卷积码是广泛应用于卫星通信、无线通信等各种... 译码器是一种具有“翻译”功能的逻辑电路,这种电路能将输入二进制代码各种状态,按照其原意翻译成对应输出信号。Viterbi译码器是以Viterbi算法为基础设计一种
  • 卷积码是广泛应用于卫星通信、无线通信等各种通信系统... 译码器是一种具有“翻译”功能的逻辑电路,这种电路能将输入二进制代码各种状态,按照其原意翻译成对应输出信号。Viterbi译码器是以Viterbi算法为基础设
  • 要设计一个(7,4)线性分组码的译码程序,最基本的是要具有对接收到的整个码组中提取信息码组的功能。但在实际的通信系统中,由于信道传输特性不理想以及加性噪声的影响,接收到的信息中不可避免地会发生错误,影响...
  • 编译环境:VC++ 6.0编程要求简述:...对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编译码系统。[基本要求]一个完整系统应具有以下功能:(l)...

    编译环境:VC++ 6.0编程要求简述:

    [问题描述]

    利用哈夫曼编码进行信息通讯可以大大提高信道利用率,缩短信息传输时间,降低传输成本。但是,这要求在发送端通过一个编码系统对待传数据预先编码;在接收端将传来的数据进行译码(复原)。对于双工信道

    (即可以双向传输信息的信道),每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编译码系统。

    [基本要求]

    一个完整的系统应具有以下功能:

    (l)I:初始化

    (Initialization)。从终端读入字符集大小n,及n个字符和m个权值,建立哈夫曼树,并将它存于文件hfmtree中。

    (2)C:编码

    (Coding)。利用已建好的哈夫曼树(如不在内存,则从文件hfmtree中读入),对文件tobetrans中的正文进行编码,然后将结果存入文件codefile中。

    (3)D:编码

    (Decoding)。利用已建好的哈夫曼树将文件codefile中的代码进行译码,结果存入文件textfile中。

    (4)P:印代码文件

    (Print)。将文件codefile以紧凑格式显示在终端上,每行50个代码。同时将此字符形式的编码文件写入文件codeprint中。

    (5)T:印哈夫曼树 (Tree

    printing)。将已在内存中的哈夫曼树以直观的方式

    (树或凹入表形式)显示在终端上,同时将此字符形式的哈夫曼树写入文件treeprint中。

    程序源代码:

    文件一:my.h(自定义头文件)

    //调用有文件以及定义常数值

    #include "stdio.h"

    #include "string.h"

    #define MAXLEN 100

    #define MAXLEN_1 1000

    //自定义类型声明

    typedef struct

    {

    int weight;

    char data;

    int lchild,rchild,parent;

    }HFMTnode;

    typedef HFMTnode HFMT[MAXLEN];

    typedef

    struct

    {

    char code[MAXLEN];

    char data;

    }HFMCnode;

    typedef HFMCnode HFMC[MAXLEN];

    typedef

    struct

    {

    char data[MAXLEN];

    int top;

    }seqstack;

    //文件全局变量外部声明

    extern int n;

    //所有子函数声明

    void InitializeTree(HFMT T);

    void InputTree(HFMT T);

    void Selectleast(HFMT T,int *p1,int *p2);

    void CreateHFMT(HFMT T);

    void push(char x);

    void hfmc(HFMT T,int i);

    void CreateHFMC(HFMT T,HFMC C);

    void Initialization(HFMT T,HFMC C);

    void Codeing(HFMC C);

    void Decodeing(HFMC C);

    void Showcodefile();

    void Showhfmt(HFMT T);

    int TreeDepth(HFMT T,int i);

    void print(HFMT T,int i,int a);

    文件二:Initialization.c(初始化)

    #include

    "my.h"

    seqstack

    s;

    //初始化树

    void InitializeTree(HFMT T)

    {

    int i;

    printf("请输入要输入的字符个数n(n应大于1):");

    scanf("%d",&n);

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

    {

    T.weight=-1;

    T.lchild=-1;

    T.rchild=-1;

    T.parent=-1;

    T.data='\0';

    }

    }

    //输入树

    void InputTree(HFMT T)

    {

    int i;

    for(i=0;i

    {

    printf("请输入第%d个字符与权重:",i+1);

    getchar();

    scanf("%c %d",&T.data,&T.weight);

    }

    }

    //从树数组中选取权值最小的两个元素

    void Selectleast(HFMT T,int *p1,int *p2)

    {

    long min1,min2;

    int i;

    min1=min2=999999;

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

    {

    if(T.parent==-1&&T.weight!=-1)

    if(T.weight

    {

    min1=T.weight;

    *p1=i;

    }

    }

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

    {

    if(T.parent==-1&&T.weight!=-1)

    if(T.weight

    {

    min2=T.weight;

    *p2=i;

    }

    }

    }

    //构建哈夫曼树

    void CreateHFMT(HFMT T)

    {

    int i,p1,p2;

    InitializeTree(T);

    InputTree(T);

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

    {

    Selectleast(T,&p1,&p2);

    T.weight=T[p1].weight+T[p2].weight;

    T.lchild=p1;

    T.rchild=p2;

    T[p1].parent=T[p2].parent=i;

    }

    }

    //入栈

    void push(char x)

    {

    s.top++;

    s.data[s.top]=x;

    }

    //构建哈夫曼树编码库递归调用函数

    void hfmc(HFMT T,int i)

    {

    int j;

    j=T.parent;

    if(j!=-1)

    {

    if(i==T[j].lchild)

    push('0');

    if(i==T[j].rchild)

    push('1');

    hfmc(T,j);

    }

    }

    //构建哈夫曼树编码库

    void CreateHFMC(HFMT T,HFMC C)

    {

    int i,j;

    s.top=-1;

    for(i=0;i

    {

    hfmc(T,i);

    C.data=T.data;

    for(j=0;s.top!=-1;j++)

    {

    C.code[j]=s.data[s.top];

    s.top--;

    }

    C.code[j]='\0';

    }

    }

    //初始化函数

    void Initialization(HFMT T,HFMC C)

    {

    FILE *out;

    int i;

    CreateHFMT(T);

    CreateHFMC(T,C);

    if((out=fopen("hfmt.dat","w"))!=NULL)

    {

    fprintf(out,"%d",n);

    for(i=0;i

    fprintf(out,"%c",T.data);

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

    fprintf(out,"\n%d %d %d

    %d",T.weight,T.parent,T.lchild,T.rchild);

    }

    else

    {

    printf("\n文件打开错误!");

    return;

    }

    fclose(out);

    printf("\n初始化完毕!");

    }

    文件三:Codeing.c(编码)

    #include

    "my.h"

    //编码函数

    void Codeing(HFMC C)

    {

    FILE

    *in,*out;

    char zw[MAXLEN],code[MAXLEN_1];

    int i=0,j,k,c_len,error=1;

    c_len=0;//编码正文初始长度置零

    //打开文件toberrans.dat并读取正文存入正文数组zw

    if((in=fopen("tobetrans.dat","r"))!=NULL)

    {

    zw=fgetc(in);

    while(feof(in)==0)

    {

    i++;

    zw=fgetc(in);

    }

    zw='\0';

    }

    else

    {

    printf("\n文件打开错误!");

    return;

    }

    fclose(in);

    //进行编码

    for(i=0;zw!='\0';i++)

    {

    error=1;//错误置为真

    for(j=0;j

    {

    if(zw==C[j].data)

    {

    for(k=0;C[j].code[k]!='\0';k++)

    {

    code[c_len]=C[j].code[k];

    c_len++;

    }

    error=0;//若编码库存在匹配字符,则错误为假

    break;

    }

    }

    if(error==1)

    break;

    }

    code[c_len]='\0';

    if(error)

    {

    printf("\n编码错误,请重新检查!");

    return;

    }

    else

    {

    printf("\n正文为:%s",zw);

    printf("\n编码为:%s",code);

    //打开文件codefile.dat,并将编码正文写入文件

    if((out=fopen("codefile.dat","w"))!=NULL)

    fprintf(out,"%s",code);

    else

    {

    printf("\n打开文件错误!");

    return;

    }

    fclose(out);

    printf("\n编码成功!");

    }

    }

    文件四:Decodeing.c(译码)

    #include

    "my.h"

    //译码函数

    void Decodeing(HFMC C)

    {

    FILE *in,*out;

    int i,j,k,c_max,c_len,dq,dq_len,flag,error=0;//error初始状态为假

    char code[MAXLEN_1],a[MAXLEN],zw[MAXLEN];

    code[0]='\0';

    //打开文件codefile.dat,读取编码正文写入内存,存入数组code

    if((in=fopen("codefile.dat","r"))!=NULL)

    {

    fscanf(in,"%s",code);

    }

    else

    {

    printf("\n打开文件错误!");

    return;

    }

    fclose(in);

    //求编码正文长度c_len

    for(i=0;code!='\0';i++);

    c_len=i;

    if(c_len==0)

    error=1;//错误情况1

    //求编码库最长编码长度c_max

    c_max=0;

    for(i=0;i

    {

    for(j=0;C.code[j]!='\0';j++);

    if(c_max

    c_max=j;

    }

    //进行译码

    dq=0; //dq用来记录code数组的读取位置

    k=0; //k用来记录zw数组读取位置

    while(dq

    {

    flag=1;

    dq_len=c_max;

    for(i=dq,j=0;j

    a[j]=code;

    a[j]='\0';

    while(flag&&!error)//若无错误且flag为1则继续循环

    {

    for(i=0;i

    {

    if(strcmp(a,C.code)==0)

    {

    zw[k]=C.data;

    k++;

    flag=0;

    break;

    }

    }//若找到编码库里匹配的编码,则结束循环

    if(flag)

    {

    dq_len--;

    a[dq_len]='\0';

    }//未找到则将当前长度减一,继续寻找

    if(dq_len<1)

    error=1;//译码错误情况2

    }

    dq=dq+dq_len;//编码正文当前读取位置改变

    }

    zw[k]='\0';//在zw数组的最后一个位置添加字符串结束符

    if(error)

    {

    printf("\n译码错误,请重新检查!");

    return;

    }

    else

    {

    //打印编码正文以及译码正文

    printf("\n编码为:%s",code);

    printf("\n译码为:%s",zw);

    //打开文件textfile.dat,将译码正文即数组zw写入文件

    if((out=fopen("textfile.dat","w"))!=NULL)

    fprintf(out,"%s",zw);

    else

    {

    printf("\n打开文件错误!");

    return;

    }

    fclose(out);

    printf("\n译码成功!");

    }

    }

    文件五:Showcodefile.c(显示代码文件)

    #include

    "my.h"

    //显示编码文件内容函数

    void Showcodefile()

    {

    FILE *in;

    char code[MAXLEN_1];

    int i;

    code[0]='\0';

    //打开文件

    if((in=fopen("codefile.dat","r"))!=NULL)

    {

    fscanf(in,"%s",code);

    }

    else

    {

    printf("\n打开文件错误!");

    return;

    }

    fclose(in);

    //打印内容

    printf("\n代码文件内容为:");

    for(i=0;code!='\0';i++)

    {

    if(iP==0)

    printf("\n");

    printf("%c",code);

    }

    }

    文件六:Showhfmt.c(以凹入法显示哈夫曼树)

    #include

    "my.h"

    //求哈夫曼树深度函数

    int TreeDepth(HFMT T,int i)

    {

    int ldep,rdep;

    if(T.lchild==-1)

    return 1;

    else

    {

    ldep=TreeDepth(T,T.lchild);

    rdep=TreeDepth(T,T.rchild);

    if(ldep>rdep)

    return ldep+1;

    else

    return rdep+1;

    }

    }

    展开全文
  • 仿真结果表明,该译码器可实现良好纠错功能。  RS(Reed-Solomon)码是差错控制领域中一种重要线性分组码,既能纠正随机错误,又能纠正突发错误,且由于其出色纠错能力,已被NASA、ESA、CCSDS等空间组织接受...
  • 仿真结果表明,该译码器可实现良好纠错功能。  RS(Reed-Solomon)码是差错控制领域中一种重要线性分组码,既能纠正随机错误,又能纠正突发错误,且由于其出色纠错能力,已被NASA、ESA、CCSDS等空间组织接受...
  • 哈夫曼树编码译码

    2019-09-23 12:59:29
    对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编/译码系统。【任务要求】 一个完整系统应具有以下功能: 1) I:初始化...

    一:问题描述

    【问题描述】
    利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接收端将传来的数据进行译码(复原)。对于双工信道(即可以双向传输信息的信道),每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。
    【任务要求】
    一个完整的系统应具有以下功能:
    1) I:初始化(Initialization)。从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文件hfmTree中。
    2) E:编码(Encoding)。利用已建好的哈夫曼树(如不在内存,则从文件hfmTree中读入),对文件ToBeTran中的正文进行编码,然后将结果存入文件CodeFile中。
    3) D:译码(Decoding)。利用已建好的哈夫曼树将文件CodeFile中的代码进行译码,结果存入文件TextFile中。

    【测试数据】
    用下表给出的字符集和频度的实际统计数据建立哈夫曼树,并实现以下报文的编码和译码:“THIS PROGRAM IS MY FAVORITE”。

    字符   A B C D E F G H I J K L M
    频度 186 64 13 22 32 103 21 15 47 57 1 5 32 20
    字符 N O P Q R S T U V W X Y Z  
    频度 57 63 15 1 48 51 80 23 8 18 1 16 1  

     

     

     

     

     

    二:大致思路

    1.构建哈夫曼树

    有n个字母待建树,申请p[2n-1]个结构体数组空间,将各个字母及其权值存入结构体数组,将数组按照权值进行排序,每次选取最小的两个构建哈夫曼树,每次从上次选择的下一个开始选择,即第一次p[0],p[1]则第二次p[2],p[3],以此类推,每次生成的从p[n+1]开始存入,直至数组就剩下一个元素,即为根节点。

    2.编码

    从叶子结点(带权字母即叶子结点,从1步骤的结构体数组那里入手,需要判断一下是否为叶子结点)开始向上回溯即寻找父节点,若为父节点左子树编码为‘0’字符,反之为‘1’字符,建个数组从最后一位往前存入直至父节点为空即根节点,直至结构体数组最后一个元素。然后将存储的字母的编码和待编码的字符串进行比对,将字符串译码为01结构,编码完成。

    3.译码

    将01结构的编码从根节点开始译码,0往左子树遍历1往右子树,直至叶节点,译码出一个字母,然后再从根节点开始,循环操作直至所有都译码完成。

    三:具体实现

    #include<iostream>
    #include<cstdio>
    #include<cstdlib>
    #include<algorithm>
    using namespace std;
    typedef struct node
    {
        char ch[2];
        int weight;
        char ldata,rdata;
        node *lchild,*rchild,*parent;
    }*huffman;
    typedef struct encoding
    {
        char ch[2];
        char *data;
    }*encode1;
    void paixu(huffman *p,int m)
    {
        huffman temp;
        for(int i=0;i<m-1;i++)
        {
            for(int j=i+1;j<m;j++)
            {
                if(p[i]->weight>p[j]->weight)
                {
                    temp=p[i];
                    p[i]=p[j];
                    p[j]=temp;
                }
            }
        }
    }
    huffman* Read(int n)                                                  //读取英文字母
    {
        huffman *huff;
        FILE *fp;
        huff=new huffman[2*n-1];
        for(int i=0;i<2*n-1;i++)
        {
            huff[i]=new node;
            huff[i]->lchild=huff[i]->rchild=NULL;
        }
        if((fp=fopen("hfmTree.txt","w"))==NULL)
        {cout<<"文件打开失败!";exit(0);}
        cout<<"please input the letter:"<<endl;
        for(int i=0;i<n;i++)
        {
            huff[i]->ch[0]=cin.get();
            if(huff[i]->ch[0]=='\n')
            huff[i]->ch[0]=cin.get();
            cin>>huff[i]->weight;
            cin.get();
            huff[i]->ch[1]='\0';
            fprintf(fp,"%s%d ",huff[i]->ch,huff[i]->weight);
        }
        cout<<"hfmTree.txt文件写入完成!"<<endl;
        fclose(fp);
        return huff;
    }
    node* Crhuffman(huffman* p,int n,int *n1)                             //创建哈夫曼树
    {
        int m=n;
        for(int i=0;i<2*n-1;i+=2)
        {
            if((m-1)!=i)
            {
                paixu(p,m);
                p[m]->weight=p[i]->weight+p[i+1]->weight;
                p[m]->lchild=p[i];
                p[m]->rchild=p[i+1];
                p[i]->parent=p[m];
                p[i+1]->parent=p[m];
                m+=1;
            }
            else
            {p[m-1]->parent=NULL;break;}
        }
        *n1=m;
        return p[m-1];
    }
    int Code(huffman *p,int n,int t,char *c,int c1,char *c2)                     //哈弗曼编码
    {
        huffman q;
        FILE *fp;
        q=new node;
        int k=0,k1=t-1,kk=0;
        encode1 *encode;
        encode=new encode1[t];
        for(int i=0;i<t;i++)
        {
            encode[i]=new encoding;
            encode[i]->data=new char[t];
        }
        for(int i=0;i<t;i++)
        {
            for(int j=0;j<t;j++)
            {
                encode[i]->data[j]='a';
            }
        }
        for(int i=0;i<n;i++)
        {
            if(p[i]->lchild==NULL&&p[i]->rchild==NULL)
            {
                q=p[i];
                encode[k]->ch[0]=p[i]->ch[0];
                while(q->parent!=NULL)
                {
                    if(q->parent->lchild==q)
                    encode[k]->data[k1]='0';
                    else
                    encode[k]->data[k1]='1';
                    q=q->parent;
                    k1=k1-1;
                }
                k+=1;
                k1=t-1;
            }
        }
        if((fp=fopen("CodeFile.txt","w"))==NULL)
        {cout<<"文件打开失败!"<<endl;exit(0);}
        for(int i=0;i<t;i++)
        {
            encode[i]->ch[1]='\0';
            fprintf(fp,"%s:",encode[i]->ch);
            for(int j=0;j<t;j++)
            {
                if(encode[i]->data[j]!='a')
                {
                   fprintf(fp,"%c",encode[i]->data[j]);
                   if(j==t-1)
                   fprintf(fp,"\n");
                }
            }
        }
        for(int i=0;i<c1;i++)//编码
        {
            for(int j=0;j<t;j++)
            {
                if(c[i]==encode[j]->ch[0])
                for(int k2=0;k2<t;k2++)
                {
                    if(encode[j]->data[k2]!='a')
                    {
                      c2[kk]=encode[j]->data[k2];
                      kk+=1;
                    }
                }
            }
        }
        c2[kk]='\0';
        fprintf(fp,"#题目所给英文编码: %s",c2);
        cout<<"CodeFile文件写入完成!"<<endl;
        fclose(fp);
        return kk;
    }
    int Readtxt(char *c)                                            //读取英文字符串
    {
        int m=0;
        FILE *fp;
        cout<<"请输入需要编码的大写英文:"<<endl;
        if((fp=fopen("ToBeTran.txt","w"))==NULL)
        {cout<<"文件打开失败!";exit(0);}
        for(int i=0;;i++)
        {
                c[i]=cin.get();
                if(c[i]=='\n')
                {c[i]='\0';break;}
                m+=1;
        }
        fprintf(fp,"%s",c);
        fclose(fp);
        cout<<"ToBeTran.txt文件写入完成!"<<endl;
        return m;
    }
    void Initialization(huffman **p,node **p1,int &n,int &n1)             //初始化
    {
        cout<<"请输入待插入英文字母个数:"<<endl;
        cin>>n;
        *p=Read(n);
        *p1=Crhuffman(*p,n,&n1);
    }
    void Encoding(int &c1,char **c,char **c2,int n,int n1,huffman *p)    //编码
    {
        c1=Readtxt(*c);
        Code(p,n1,n,*c,c1,*c2);
    }
    void Decoding(node *p1,char *c)                                      //译码
    {
        int k=0,i=0;
        FILE *fp;
        node *p=p1;
        if((fp=fopen("TextFile.txt","w"))==NULL)
        {cout<<"文件打开失败!";exit(0);}
        while(c[i]!='\0')
        {
            while(c[i]!='\0')
            {
                if(c[i]=='0')
                {
                    p=p->lchild;
                    if(p->lchild==NULL&&p->rchild==NULL)
                    {i++;break;}
                }
                else
                {
                    p=p->rchild;
                    if(p->lchild==NULL&&p->rchild==NULL)
                    {i++;break;}
                }
                i++;
            }
            fprintf(fp,"%s",p->ch);p=p1;
        }
        fclose(fp);cout<<"TextFile.txt文件写入完成!"<<endl;
    }
    void Print()                                                //打印
    {
        FILE *fp,*fp1;
        char ch[1000];
        if((fp=fopen("CodeFile.txt","r"))==NULL)
        {cout<<"文件打开失败!"<<endl;exit(0);}
        if((fp1=fopen("CodePrint.txt","w"))==NULL)
        {cout<<"文件打开失败!"<<endl;exit(0);}
        while(!feof(fp))
        {
            fscanf(fp,"%s",ch);
            if(ch[0]=='#')
            {
                cout<<ch<<endl;
                fscanf(fp,"%s",ch);
                fprintf(fp1,"%s",ch);
            }
            cout<<ch<<endl;
        }
        fclose(fp);
        fclose(fp1);
    }
    void Tree_printing(node *p1)
    {
        FILE *fp;
        if((fp=fopen("TreePrint.txt","a"))==NULL)
        {cout<<"文件打开失败!"<<endl;exit(0);}
        if(p1)
        {
            if(p1->ch[0]==NULL)
            {
                cout<<""<<p1->weight<<"    ";
                fprintf(fp,"空%d\n",p1->weight);
            }
    
            else
            {
                cout<<p1->ch[0]<<p1->weight<<"     ";
                fprintf(fp,"%c%d\n",p1->ch[0],p1->weight);
            }
    
            Tree_printing(p1->lchild);
            Tree_printing(p1->rchild);
        }
    }
    void homepage()
    {
        cout<<"****************************************************************************"<<endl;
        cout<<"               1.Initialization()&&Encoding()    //初始化并编码             "<<endl;
        cout<<"               2.Decoding()                      //译码                     "<<endl;
        cout<<"               3.Print()                         //打印代码文件             "<<endl;
        cout<<"               4.Tree_printing()                 //打印哈夫曼树             "<<endl;
        cout<<"               5.Confirm exit                    //确认退出                 "<<endl;
        cout<<"****************************************************************************"<<endl;
        cout<<"请选择需要的操作:"<<endl;
    }
    void display()
    {
        int N;huffman *p,i=0;
        node *p1;
        encode1 *q;
        char *c,*c2;
        c=new char[100];
        c2=new char[1000];
        int n,n1,c1,n2;
        homepage();
        cin>>N;
        while(1)
        {
             // system("cls");
              if(N==1)
              {
                  Initialization(&p,&p1,n,n1);
                  Encoding(c1,&c,&c2,n,n1,p);
                  i+=1;
              }
              else if(N==2)
              {
                  if(i==0)
                  {cout<<"操作不合法,请重新输入!"<<endl;}
                  else
                  {Decoding(p1,c2);i+=1;}
              }
              else if(N==3)
              {
                  if(i==0)
                  {cout<<"操作不合法,请重新输入!"<<endl;}
                  else
                  {cout<<" ";Print();i+=1;}
              }
              else if(N==4)
              {
                if(i==0)
                {cout<<"操作不合法,请重新输入!"<<endl;}
                else
                {Tree_printing(p1);i+=1;cout<<endl;}
              }
              else if(N==5)
              exit(0);
              else
              printf("输入不合法,请重新输入!\n");
              homepage();
              cin>>N;
        }
    }
    int main()
    {
        display();
    }

    四:运行结果

     

    五:总结

    1.字母以字符形式写入文件时会乱码,不能用%c,可以改为%s整体写入,注意字符数组末尾要加‘\0’转为字符串。

    2.将指针传入函数,想改变指针的值即传入的指针再调用完后改变,即如test(p)(main 函数里的),void test(int **p)(main函数外的),需要设二级指针,即指向指针的指针,指针也是变量,和普通变量一样,只不过是地址类型,而且可以访问指针所存地址里的东西。

    3.结构体数组即每个元素都是结构体,指向结构体的二级指针即二级指针元素是一级指针,一级指针元素是结构体类型数据。

     

     

     

    转载于:https://www.cnblogs.com/Lovezxy/p/11552896.html

    展开全文
  • 一个完整系统应具有以下功能: I:初始化(Initialization)。从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文件hfmTree中。 E:编码(Encoding)。利用已建好哈夫曼树(如不在内存,...
  • 哈夫曼编/译码

    2016-03-07 21:35:39
    对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编译码系统。 基本要求 一个完整系统应具有以下功能: (1)I:初始化(Initialization)。从...
  • 数据结构——哈夫曼编码译码

    千次阅读 多人点赞 2019-01-09 11:19:03
    题目5: 哈夫曼编/译码器...对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编/译码系统。 [基本要求] 一个完整系统应具有以下功能: 1、I:初...

    题目5: 哈夫曼编/译码器 [问题描述]
    利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。但是,这要求在发送端通过一个编码系统对待传数据预先编码,在接收端将传来的数据进行译码(复原)。对于双工信道(即可以双向传输信息的信道),每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。
    [基本要求] 一个完整的系统应具有以下功能:
    1、I:初始化(Initialization)。从终端读入字符集大小n,以及n个字符和n个权值,建立哈夫曼树,并将它存于文件hfmTree中。
    2、 E:编码(Encoding)。利用以建好的哈夫曼树(如不在内存,则从文件hfmTree中读入),
    对文件ToBeTran中的正文进行编码,然后将结果存入文件CodeFile中。
    3、D:译码(Decoding)。利用已建好的哈夫曼树将文件CodeFile中的代码进行译码,结果存入文件TextFile中。 1、
    P:打印代码文件(Print)。将文件CodeFile以紧凑格式显示在终端上,每行50个代码。
    同时将此字符形式的编码文件写入文件CodePrin中。 2、 T:打印哈夫曼树(Tree
    Printing)。将已在内存中的哈夫曼树以直观的方式(树或凹入
    表形式)显示在终端上,同时将此字符形式的哈夫曼树写入文件TreePrint中。

    代码:

    //要编码的正文存储在tobetran.txt文件中,得到的结果存入codefile文件中
    //译码的结果存在于textfile.txt文件中
    //二进制编码存在于codeprin中
    //哈夫曼树存在于treeprin中
    //-abcdefghijklmnopqrstuvwxyz
    //186 64 13 22 32 103 21 15 47 57 1 5 32 20 57 63 15 1 48 51 80 23 8 18 1 16 1
    //this problem is my favourite
    
    #include <iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    #include<cmath>
    using namespace std;
    typedef struct
    {
        int weight; //节点权值
        int lchild,rchild,parent; //左右孩子和双亲的下标
    } HTNode,*HuffmanTree;
    
    void menu()
    {
        cout<<"================================================="<<endl;
        cout<<"|        ******哈夫曼树编码与译码******         |"<<endl;
        cout<<"|                1.创建哈夫曼树                 |"<<endl;
        cout<<"|                2.生成二进制码                 |"<<endl;
        cout<<"|                3.哈夫曼编码                   |"<<endl;
        cout<<"|                4.哈夫曼译码                   |"<<endl;
        cout<<"|                5.显示代码文件                 |"<<endl;
        cout<<"|                6.打印哈夫曼树                 |"<<endl;
        cout<<"|                7.退出                         |"<<endl;
        cout<<"================================================="<<endl;
    }
    
    void Select(HuffmanTree HT,int n,int &s1,int &s2)
    {
        int i=1;
        while(HT[i].parent!=0&&i<=n)
            i++;
        if(i==n+1)
            return ;
        s1=i;
        i++;
        while(HT[i].parent!=0&&i<=n)
            i++;
        if(i==n+1)
            return ;
        s2=i;
        i++;
        if(HT[s1].weight>HT[s2].weight)
            swap(s1,s2);
        for(; i<=n; i++)
        {
            if(HT[i].parent==0)
            {
                if(HT[i].weight<HT[s1].weight)
                    s2=s1,s1=i;
                else if(HT[i].weight<HT[s2].weight)
                    s2=i;
            }
        }
        return ;
    }
    
    void CreatHuffmanTree(HuffmanTree &HT,int n)
    {
        if(n<=1)
            return ;
        int m=2*n-1;
        HT=(HuffmanTree)malloc(sizeof(HTNode)*(m+1));
        for(int i=1; i<=m; i++)
        {
            HT[i].lchild=0;
            HT[i].parent=0;
            HT[i].rchild=0;
            HT[i].weight=0;
        }
        for(int i=1; i<=n; i++)
            cin>>HT[i].weight;
        int s1,s2;
        for(int i=n+1; i<=m; i++)
        {
            Select(HT,i-1,s1,s2);
            HT[s1].parent=i;
            HT[s2].parent=i;
            HT[i].lchild=s1;
            HT[i].rchild=s2;
            HT[i].weight=HT[s1].weight+HT[s2].weight;
        }
        return ;
    
    }
    
    void CreatHuffmanCode(HuffmanTree &HT,char ** &HC,int n)
    {
        char *col;
        HC=(char **)malloc(sizeof(char *)*(n+1));  //分配n个字符编码的头指针向量
        col=(char *)malloc(sizeof(char)*n);   //分配求编码的工作空间
        col[n-1]='\0';
        for(int i=1; i<=n; i++)
        {
            int str=n-1;
            int p=i,f=i;
            while(HT[f].parent!=0)      //从叶子到根逆向求编码
            {
                f=HT[f].parent;
                if(HT[f].lchild==p)
                    col[--str]='0';
                else if(HT[f].rchild==p)
                    col[--str]='1';
                p=f;
            }
            HC[i]=(char *)malloc(sizeof(char)*(n-str));    //为第i个字符编码分配空间
            strcpy(HC[i],&col[str]);   //把编码串复制到HC中
        }
        free(col);
        return ;
    }
    
    void TransCode(HuffmanTree HT,char b[],char a[],char c[],int n)
    {
        //b数组是要翻译的二进制编码
        //a数组是叶子对应的字符
        //c数组存储翻译得到的内容
        FILE *fw;
        int q=2*n-1;   //初始化为根结点的下标
        int k=0;
        int len=strlen(b);
        if((fw=fopen("textfile.txt","w"))==NULL)
            cout<<"Open file error!"<<endl;
        for(int i=0; i<len; i++)
        {
            if(b[i]=='0')
                q=HT[q].lchild;
            else if(b[i]=='1')
                q=HT[q].rchild;
            if(HT[q].lchild==0&&HT[q].rchild==0)   //叶子节点,此时可以译出字符
            {
                c[k++]=a[q];
                fputc(a[q],fw);
                q=2*n-1;
            }
            c[k]='\0';
        }
        return ;
    }
    
    void Coding(HuffmanTree &HT,char ** &HC,int n,char a[])
    {
        FILE *fp,*fw;
        char c;
        int k;
       /* char c,*cd;
        int k,j,jj;
        HC=(char **)malloc((2*n-1)*sizeof(char *));
        cd=(char *)malloc((2*n-1)*sizeof(char));
        cd[n-1]='\0';
        for(int i=1;i<=n;i++)
        {
            int str=n-1;
            for(j=i,jj=HT[i].parent;j!=0;j=jj,jj=HT[jj].parent)
                if(HT[jj].lchild==j)
                    cd[--str]='0';
                else
                    cd[--str]='1';
            HC[i]=(char *)malloc((n-str)*sizeof(char));
            strcpy(HC[i],&cd[str]);
        }
        free(cd);
        */
        if((fp=fopen("tobetran.txt","r"))==NULL)
            cout<<"Open file error!"<<endl;
        if((fw=fopen("codefile.txt","w"))==NULL)
            cout<<"Open file error!"<<endl;
        fscanf(fp,"%c",&c);
        while(!feof(fp))
        {
            for(int i=1; i<=n; i++)
                if(a[i]==c)
                {
                    k=i;
                    break;
                }
            for(int i=0; HC[k][i]!='\0'; i++)
                fputc(HC[k][i],fw);
            fscanf(fp,"%c",&c);
        }
        fclose(fp);
        fclose(fw);
        return ;
    }
    
    void printf_code()
    {
        FILE *fp,*fw;
        char temp;
        if((fp=fopen("codefile.txt","r"))==NULL)
            cout<<"Open file error!"<<endl;
        if((fw=fopen("codeprin.txt","w"))==NULL)
            cout<<"Open file error!"<<endl;
        cout<<"文件codefile.txt的内容显示如下:"<<endl;
        fscanf(fp,"%c",&temp);
        for(int i=1;!feof(fp);i++)
        {
            printf("%c",temp);
            if(i%50==0)
                cout<<endl;
            fputc(temp,fw);
            fscanf(fp,"%c",&temp);
        }
        cout<<endl;
        cout<<"该编码文件已存入文件codeprin.txt中!"<<endl;
        fclose(fp);
        fclose(fw);
    }
    
    void co_tree(unsigned char T[100][100],int s,int *m,int j,HuffmanTree HT)
    {
        int k,l;
        l=++(*m);
        for(k=0;k<s;k++)
            T[l][k]=' ';
        T[l][k]=HT[j].weight;
      //    itoa(HT[j].weight,T[l][k],10);
      /*  int weishu=log10(HT[j].weight);
        int base=10;
         while(weishu)
         {
             base*=base;
             weishu--;
         }
        while(HT[j].weight)
        {
           T[l][k]=HT[j].weight/base;
           HT[j].weight/=10;
           base/=10;
           k++;
        }
        */
        if(HT[j].lchild)
            co_tree(T,s+1,m,HT[j].lchild,HT);
        if(HT[j].rchild)
            co_tree(T,s+1,m,HT[j].rchild,HT);
        T[l][++k]='\0';
        return ;
    }
    
    void printf_tree(int num,HuffmanTree HT)
    {
        unsigned char T[100][100];
        FILE *fp;
        int m=0;
        co_tree(T,0,&m,2*num-1,HT);
        if((fp=fopen("treeprin.txt","w"))==NULL)
            cout<<"Open file error!"<<endl;
        for(int i=1;i<=2*num-1;i++)
        {
            for(int j=0;T[i][j]!='\0';j++)
            {
                if(T[i][j]==' ')
                   printf(" "),fputc(T[i][j],fp);
                else
                    printf("%u",T[i][j]),fprintf(fp,"%u",T[i][j]);
            }
             cout<<endl;
             fputc(10,fp);
        }
        cout<<"该哈夫曼树已保存到treeprin.txt文件中!"<<endl;
        fclose(fp);
        return ;
    }
    
    int main()
    {
        char a[300]; //存储要编码的所有字符
        char b[300];  //存储要翻译的二进制编码
        char c[300]; //存储翻译出来的结果
        HuffmanTree HT=NULL;
        char ** HC;
        while(1)
        {
            char s1[]= {"结点"};
            char s2[]= {"字符"};
            char s3[]= {"权值"};
            char s4[]= {"双亲"};
            char s5[]= {"左孩子"};
            char s6[]= {"右孩子"};
            int flag=1;
            menu();
            int choose;
            int num;
            char temp;
            int cc=0;
            cout<<"请选择你要进行的操作(1-4):";
            cin>>choose;
            switch(choose)
            {
            case 1:
                cout<<"请输入字符的个数:";
                cin>>num;
                cout<<"请依次输入"<<num<<"个字符:(空格用-来代替)";
                for(int i=1; i<=num; i++)
                    cin>>a[i];
                cout<<"请依次输入"<<num<<"个字符的权值:";
                CreatHuffmanTree(HT,num);
                cout<<"创建哈夫曼树成功,下面输出该哈夫曼树的参数。"<<endl;
                cout<<"结点i"<<"\t字符"<<"\t权值"<<"\t双亲"<<"\t左孩子"<<"\t右孩子"<<endl;
                for(int i=1; i<=num*2-1; i++)
                    cout<<i<<"\t"<<a[i]<<"\t"<<HT[i].weight<<"\t"<<HT[i].parent<<"\t"<<HT[i].lchild<<"\t"<<HT[i].rchild<<endl;
                FILE *fp;
                if((fp=fopen("hfmtree.txt","w"))==NULL)
                    cout<<"Open file hfmtree error!"<<endl;
                // char ceshi[10];
                // scanf("%s",ceshi);
                // fwrite(&ceshi,sizeof(ceshi),1,fp);
                fwrite(&s1,sizeof(s1),1,fp);
                fwrite(&s2,sizeof(s2),1,fp);
                fwrite(&s3,sizeof(s3),1,fp);
                fwrite(&s4,sizeof(s4),1,fp);
                fwrite(&s5,sizeof(s5),1,fp);
                fwrite(&s6,sizeof(s6),1,fp);
                fputc(10,fp);
                for(int i=1; i<=2*num-1; i++)
                {
                    fprintf(fp,"%-3d  ",i);
                    fwrite(&a[i],1,1,fp);
                    fprintf(fp,"    %-3d    ",HT[i].weight);
                    fprintf(fp,"%-3d    ",HT[i].parent);
                    fprintf(fp,"%-3d    ",HT[i].lchild);
                    fprintf(fp,"%-3d    ",HT[i].rchild);
                    fputc(10,fp);
                }
                fclose(fp);
                cout<<"哈夫曼树已建成并存入文件中!"<<endl;
                break;
            case 2:
                CreatHuffmanCode(HT,HC,num);
                cout<<"哈夫曼编码表已生成,下面输出哈夫曼编码表!"<<endl;
                cout<<"结点i\t"<<"字符\t"<<"权值\t"<<"编码\t"<<endl;
                for(int i=1; i<=num; i++)
                    cout<<i<<"\t"<<a[i]<<"\t"<<HT[i].weight<<"\t"<<HC[i]<<endl;
                break;
            case 3:
                cout<<"从文件tobetran.txt中读取正文进行编码"<<endl;
                Coding(HT,HC,num,a);
                cout<<"已编码成功,对应二进制编码已存入文件codefile.txt中!"<<endl;
                break;
            case 4:
                cout<<"从codefile.txt文件中读取一串二进制进行翻译:"<<endl;
                if((fp=fopen("codefile.txt","rb"))==NULL)
                    cout<<"Open file error!"<<endl;
                while(1)
                {
                    temp = fgetc(fp); //读一个字节。
                    if(temp == EOF) break; //到文件尾,退出循环。
                    b[cc++] =temp ;//赋值到字符数组中。
                }
                b[cc]='\0';
                cout<<"该二进制是:";
                printf("%s\n",b);
                fclose(fp);
                TransCode(HT,b,a,c,num);
                cout<<"翻译成功,翻译结果为:";
                printf("%s\n",c);
                cout<<"该翻译结果已存入文件textfile.txt中!"<<endl;
                break;
            case 5:
                printf_code();
                break;
            case 6:
                cout<<"下面打印哈夫曼树:"<<endl;
                printf_tree(num,HT);
                break;
            case 7:
                flag=0;
                break;
            default:
                cout<<"输入不合法,请重新输入!"<<endl;
                continue;
            }
            if(flag==0)
                break;
        }
    
        return 0;
    }
    
    
    展开全文
  • 对于双工信道(即可以双向传输俏息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编/译码系统。 二、基本要求 一个完挂系统应具有以下功能: (1) I:初始化(Initialization...
  • 哈夫曼编/译码器.zip

    2019-10-31 15:12:14
    对于双工信道( 即可以双向传输信息的信道 ), 每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编译码系统。 [ 基本要求 ] 一个完整系统应具有以下功能: (1) I:初始化(Initialization)。...
  • 3到4个程序和文档任选 :【问题描述】 利用哈夫曼编码进行信息通讯可以大大提高信道...(4)用下表给出字符集和频度实际统计数据建立哈夫曼树,并实现以下报文编码和译码:“THIS PROGRAM IS MY FAVORITE”。
  • ** ◆5.2③哈夫曼编/译码器 ** [问题描述] 利用哈夫曼编码进行通信可以大大提高信道利用率,缩短信息...一个完整系统应具有以下功能: (1) I:初始化(Initialization)。从终端读入字符集大小n,以及n个字符和n个权值, .
  • 由于该过程涉及到了多个过程,为增强代码可读性和可移植性,我们将其分为了主函数和子函数,其各自...4) 子函数3,BPBEC:删除信道BP译码过程。 下面分块给出代码: 1.主函数 % 删除信道误帧率计算 clc; ...
  • 利用哈夫曼编码进行通信可以大大提高信道利用率...对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编/译码系统。要求一个完整系统应具有以下功能:
  • 对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼编/译码系统。 [基本要求] 一个完整系统应具有以下功能: (1)I:初始化(Initialization)。从...
  • 一、题目 ...对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站编写一个赫夫曼码编/译码系统。 2.基本要求 一个完整系统应具有以下功能: (1)...
  • 3.哈夫曼编/译码系统

    2011-06-29 17:06:00
    对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编/译码系统。 【基本要求】一个完整系统应具有以下功能: (1)I:初始化(Initializa...
  • 对于双工信道(即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编译码系统。 一个完整哈夫曼码编译码系统系统应具有以下功能: I: 初始化(Initialization)...
  • 对于双工信道 (即可以双向传输信息的信道),每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编译码系统。 基本要求: 一个完整系统应具有以下功能: (l)I:初始化 (Initialization)。从...
  • 哈夫曼编码/译码(实验文档)

    万次阅读 2006-12-05 00:35:00
    哈夫曼编码/译码一、【实验内容】【问题描述】 利用哈夫曼编码进行住处通讯可以大大提高信道利用率,缩短住处传输时间,降低成本,但是,这要求在发送端通过一个编码系统将传输数据预先编码,在接收端通过一个译码系统...
  • 对于双工信道(可以双向传输信息的信道)每端都需要一个完整编/译码系统。试为这样信息收发站写一个哈夫曼码编/译码系统。 一个完整系统应具有以下功能: (1) I:初始化(Initialization)。从终端读人字符...
  •  KS57C2616B集成电路内部包括中央处理器,用以完成各种控制信号输入/输出,FSK译码、各种信号指令接收检测和转发,以及信道的选择、提供系统时钟、发射与接收静双音频/脉冲拨号选择,振铃信号检测、指示灯...
  • 信息系统基本功能

    2019-05-30 09:12:59
    信息系统具有数据输入、传输、存储、处理、输出等基本功能 数据采集和输入。识别信息有三种方法:一是有决策者识别;而是系统分析员亲自观察识别;... 信源(信息)编码(信号)信道(信号+噪音)译码(信息)信宿 ...
  • 再配合信道译码器做多信道的扫瞄,以此HT45R38就可侦测到那个通道的状态被改变了。  HT45R38是一颗ROM为4kx15、RAM为192 bytes、I/O最多为29埠的MCU,HT45R38除了有C/R-F的功能与大电流输出端口的特色外,增加了5...
  • 再配合信道译码器做多信道的扫瞄,以此HT45R38就可侦测到那个通道的状态被改变了。  HT45R38是一颗ROM为4kx15、RAM为192字节、I/O最多为13埠的MCU,HT45R38除了有C/R-F的功能与大电流输出端口的特色外,增加了5个...
  • 再配合信道译码器做多信道的扫瞄,以此HT45R38就可侦测到那个通道的状态被改变了。 HT45R38是一颗ROM为4kx15、RAM为192 bytes、I/O最多为29端口的MCU,HT45R38除了有C/R-F的功能与大电流输出端口的特色外,增加了5...

空空如也

空空如也

1 2 3 4 5
收藏数 93
精华内容 37
关键字:

信道译码的功能