【光纖通信】光纖光栅傳感網接入GPON的matlab仿真

1.軟體版本

MATLAB2019a

2.本算法理論知識

發送部分：

根據論文中的需求，發送端可以設計為如下的結構：

·傳感器接收到的資訊轉換為二進制資訊（這個我們可以直接模拟出随機的二進制序列來表示傳感器的資料，首先設定一組資料，然後進行量化，最後進行轉換為二進制。這個部分的仿真結果對應你提供論文的3.2.1部分）

·封裝，将編碼後的資料進行封裝，即将資料變為資料包，再把資料包轉換為資料幀

·碼率調整，主要将瞬時數位率不同的多個數位流調整為具有同一較高的數位率的數位流，然後再進行時分複接。

·最後由時分複接得到傳感複用幀結構。

·碼分編碼封裝發送(二進制資料編碼，這裡，編碼方式我們選擇性能非常好的LDPC編碼)

在發送端，這裡根據仿真要求，模拟五個子網

接收部分：

碼分解碼，解封裝，分接，碼率恢複，解幀，拆包，譯碼。。。。。

最後我們對整個系統進行誤碼率的分析，對五個子網的資料進行誤碼率分析，眼圖以及Q因子分析。

3.部分核心代碼

clc;
clear;
close all;
warning off;
pack;
addpath 'func\'

%是否顯示中間結果的波形
%fig1:模拟傳感器采集到的資料
%fig2:模拟傳感器采集到的資料的淨荷值
%fig3:五路傳感器資料
%fig4:解封裝sync位置
%fig5:顯示标準眼圖
%fig6:顯示噪聲幹擾眼圖
%fig7:顯示譯碼之後眼圖
is_show = [0 0 0 0 0 0 0];

Ind     = 0;
%參數初始化
EbN0    = [0:0.5:6];
TIMES   = 10;

Err_Rate0  = zeros(1,length(EbN0));
Err_Rate0s = zeros(1,TIMES);
Err_Rate1  = zeros(1,length(EbN0));
Err_Rate1s = zeros(1,TIMES);
Err_Rate2  = zeros(1,length(EbN0));
Err_Rate2s = zeros(1,TIMES);
Err_Rate3  = zeros(1,length(EbN0));
Err_Rate3s = zeros(1,TIMES);
Err_Rate4  = zeros(1,length(EbN0));
Err_Rate4s = zeros(1,TIMES);
Err_Rate5  = zeros(1,length(EbN0));
Err_Rate5s = zeros(1,TIMES);

Q1         = zeros(1,length(EbN0));
Q2         = zeros(1,length(EbN0));
Q3         = zeros(1,length(EbN0));
Q4         = zeros(1,length(EbN0));
Q5         = zeros(1,length(EbN0));
Q0         = zeros(1,length(EbN0));

for jj1 = 1:length(EbN0)
    jj1
    Ind = Ind + 1;
    Err_Rate2 = zeros(1,TIMES);
    for jj2 = 1:TIMES
        jj2
        Num_NET = 5;%模拟子網的個數
        Lens    = 500;%傳感器采集資料長度
        %傳感資訊的淨荷值相關參數
        A       = -40;
        B       = 120;
        Delta   = 0.2;
        Ld      = (ceil(log2((B-A)/Delta)));
        %傳感子網資料幀的封裝
        Preamble=[0,1,1,1,1,1,1,0];%幀前導碼取特殊字元串01111110，表示幀同步，便于傳感監控中心判斷出幀的起始位置，
        %子網ID号，本案為5個子網，是以ID為三bit資料,但是為了具有擴充性，ID用四個bit表示
        ID      =[0,0,0,0;
                  0,0,0,1;
                  0,0,1,0;
                  0,0,1,1;
                  0,1,0,0];
        %HEC為幀頭校驗碼
        HEC     = [0,1,0,1]; 
        %標頭
        Head    = [0,0,1,1,0,0,1,1];
        %address,位址，随着采集資料，位址逐漸加1
        %傳感器類型,假設五個子網，每個子網就一種類型
        type1   = [0,0,0,1;
                   0,0,1,0;
                   0,0,1,1;
                   0,1,0,0;
                   0,1,0,1];
        %包尾
        Trail   = [1,1,0,0,1,1,0,0];
        Bao_Size= 10;

        %最後的複用幀的相關參數
        Sync      = [0,0,0,0,0,0,1,1,1,0,1,0,1,1,1,1,1,0,0,0,1,0,1,1,0,0,0,0,0,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,0];
        Separator = [0,1,0,1];
        FCS       = [1,0,0,1,1,0,1,1,1,0,0,1,1,0,0,1];
        N         = 5;
        M         = 5;

        %第一部分，系統發送部分
        %第一部分，系統發送部分

        %本案共有五個子網，是以模拟五組資料
        for nn = 1:Num_NET
            %模拟産生傳感器采集到的資料,這裡，為了模拟不同的碼率，将采集的資料長度設定為不同
            y     = func_sensor_samples(Lens,A,B);
            YY{nn} = y;
            if is_show(1) == 1
               figure(1);
               plot(y,'b');
               xlabel('times');
               ylabel('amplitude')
               title('模拟傳感器采集到的資料');
               pause(0.1);
            end
            %光纖光栅傳感信号的淨荷值的二進制轉換
            Lp = func_value2realvalue(y,A,B,Delta);
            if is_show(2) == 1
               figure(2);
               plot(Lp,'b');
               xlabel('times');
               ylabel('amplitude')
               title('模拟傳感器采集到的資料的淨荷值');
               pause(0.1);
            end
            %計算轉換為二進制
            V2 = func_dec2bin(Lp,Ld);
            %将二進制轉換為串行流
            Signal{nn} = (reshape(V2',size(V2,1)*size(V2,2),1))';%通過上面的步驟，我們模拟了實際要發送的二進制碼流
        end
        if is_show(3) == 1
           figure(3);
           subplot(321);
           plot(YY{1});title('第1個子網傳感器采集資料波形');
           subplot(322);
           plot(YY{2});title('第2個子網傳感器采集資料波形');
           subplot(323);
           plot(YY{3});title('第3個子網傳感器采集資料波形');
           subplot(324);
           plot(YY{4});title('第4個子網傳感器采集資料波形');
           subplot(325);
           plot(YY{5});title('第5個子網傳感器采集資料波形');
           pause(0.1);
        end

        %Signal即為實際要發送的二進制碼流
        %産生資料包資料包,這裡，我們假設每個資料包中為10個采樣資料，即100bit資料
        address = 0;
        for nn = 1:Num_NET
            tmps2   = [];
            tmps    = [];
            address = 0;
            for i = 1:length(Signal{nn})/(Bao_Size*Ld)
                address  = address + 1;
                address2 = func_dec2bin_addr(address);
                %位址轉換為2進制，8bit辨別,這樣，每個包共128bit
                tmps     = [Head,address2,type1(nn,:),Signal{nn}((i-1)*Bao_Size*Ld+1:i*Bao_Size*Ld),Trail];
                Len_bao  = length(tmps);
                tmps2    = [tmps2 tmps];
            end
            Signal2{nn} = tmps2;
        end
        %由資料幀轉換為傳感幀
        for nn = 1:Num_NET
            tmps2   = [];
            tmps    = [];
            for i = 1:length(Signal2{nn})/(N*Len_bao)
                tmps     = [Preamble,ID(nn,:),HEC,Signal2{nn}((i-1)*Len_bao*N+1:i*Len_bao*N)];
                Len_zhen = length(tmps);
                tmps2    = [tmps2 tmps];
            end
            Signal3{nn} = tmps2;
        end
        %對五個子網的資料進行時分複接
        %碼率調整
        Out1 = func_Rate_sync(Signal3{1});
        Out2 = func_Rate_sync(Signal3{2});
        Out3 = func_Rate_sync(Signal3{3});
        Out4 = func_Rate_sync(Signal3{4});
        Out5 = func_Rate_sync(Signal3{5});
        %時分複接
        Out  = func_tdma(Out1,Out2,Out3,Out4,Out5,Len_zhen);
        %傳感複用幀
        tmps2   = [];
        tmps    = [];
        for i = 1:length(Out)/(M*Len_zhen)
            tmps      = [Sync,Separator,Out((i-1)*M*Len_zhen+1:i*M*Len_zhen),Separator,FCS];
            Len_zhen2 = length(tmps);
            tmps2     = [tmps2 tmps];
        end
        Signal4 = tmps2;

        %進行編碼，編碼矩陣為96*192，每次取80,并補充16個0作為虛拟填充符進行編碼，共96個資料進行編碼
        load H;
        load G;
        Trans_Signal = [];
        for i = 1:length(Signal4)/80
            Trans_data   = [zeros(1,16),Signal4((i-1)*80+1:(i)*80)];
            %編碼
            data_code    = mod(Trans_data*G,2); 
            %BPSK
            Trans_BPSK   = 2*data_code-1; 
            Len_code     = length(Trans_BPSK);
            Trans_Signal = [Trans_Signal,Trans_BPSK];
        end



        %第二部分，信道，信道部分，由于是光纖傳輸，且您論文中沒有詳細說明這個部分内容，是以這裡暫時僅考慮高斯白噪聲
        %第二部分，信道，信道部分，由于是光纖傳輸，且您論文中沒有詳細說明這個部分内容，是以這裡暫時僅考慮高斯白噪聲
        sigma      = sqrt(1./(10^(EbN0(Ind)/10)*0.5)); 
        Rec_Signal = Trans_Signal + sigma*randn(1,length(Trans_Signal));   


        %第三部分，監控中心——接收端
        %第三部分，監控中心——接收端
        %譯碼
        R_Signal = [];
        for i = 1:length(Signal4)/80
            z_hat       = func_Dec(Rec_Signal((i-1)*Len_code+1:i*Len_code),sigma,H,50);
            x_hat       = z_hat(size(G,2)+1-size(G,1):size(G,2));
            R_Signal    = [R_Signal,x_hat(17:end)'];%去掉16個填充符
        end

        
        if is_show(5) == 1
           st = func_eye(Trans_Signal);
           eyediagram(st,40)
           ylabel('信号幅度');
           title('原始信号眼圖');     
           pause(0.1);
        end        
        if is_show(6) == 1
           st = func_eye(Rec_Signal);
           eyediagram(st,40)
           ylabel('信号幅度');
           title('接收帶噪聲幹擾信号眼圖');  
           pause(0.1);
        end          
        if is_show(7) == 1
           st = func_eye(R_Signal*2-1);
           eyediagram(st,40)
           ylabel('信号幅度');
           title('譯碼之後信号眼圖'); 
           pause(0.1);
        end         
        
        
        %解封裝
        %通過搜尋sync來确定每幀的幀頭
        [R_Signal,Sync_pos] = func_find_sync(R_Signal,Sync);
        if is_show(4) == 1
           figure(4);
           plot(Sync_pos,'b');
           hold on;
           plot(find(Sync_pos>=40),Sync_pos(find(Sync_pos>=40)),'r*');
           hold off;
           xlabel('times');
           ylabel('amplitude')
           title('解封裝sync位置');
           pause(0.1);
        end
        %判斷目前幀位置能否檢測到幀頭
        if_sync = zeros(1,length(Out)/(M*Len_zhen));%這個變量用來存放是否檢測到目前幀，如果為0，則該幀未檢測到，直接丢棄，檢測下一幀
        for i = 1:length(Out)/(M*Len_zhen)
            if Sync_pos(1+(i-1)*Len_zhen2) > 40
               if_sync(i)=1;
            end
        end

        %解封裝
        tmps3   = [];
        tmps2   = [];
        tmps    = [];
        for i = 1:length(Out)/(M*Len_zhen)
            if if_sync(i) == 1
               tmps = R_Signal((i-1)*Len_zhen2+1:(i)*Len_zhen2);
            else
               tmps = zeros(1,Len_zhen2);% 如果該幀沒有檢測到，那麼直接指派0
            end
            %解封裝
            tmps2 = tmps(length(Sync)+length(Separator)+1:M*Len_zhen+length(Sync)+length(Separator));
            tmps3 = [tmps3 tmps2];
        end
        Outs = tmps3;

        %數字分接單元
        [I1,I2,I3,I4,I5] = func_tdma2(Outs,Len_zhen,M);
        %對五個子網的資料進行時分複接
        %碼率調整
        Outr{1} = func_Rate_sync(I1);
        Outr{2} = func_Rate_sync(I2);
        Outr{3} = func_Rate_sync(I3);
        Outr{4} = func_Rate_sync(I4);
        Outr{5} = func_Rate_sync(I5);



        %将5路傳感幀轉換為資料幀，進一步拆封
        %由資料幀轉換為傳感幀
        for nn = 1:Num_NET
            tmps2   = [];
            tmps    = [];
            LL = length(Preamble)+length(ID(nn,:))+length(HEC);
            for i = 1:length(Signal2{nn})/(N*Len_bao)
                tmps     = Outr{nn}((i-1)*Len_zhen+1:i*Len_zhen);
                tmps2    = [tmps2 tmps(LL+1:end)];
            end
            Outr2{nn} = tmps2;
        end
        %将資料包中資料提取
        %Signal即為實際要發送的二進制碼流
        %産生資料包資料包,這裡，我們假設每個資料包中為10個采樣資料，即100bit資料
        address = 0;
        for nn = 1:Num_NET
            tmps2   = [];
            tmps    = [];
            LL      = length(Head)+length(address2)+length(type1(nn,:));
            for i = 1:length(Signal{nn})/(Bao_Size*Ld)
                tmps  = [Outr2{nn}((i-1)*Len_bao+1:i*Len_bao)];
                tmps2 = [tmps2 tmps(LL+1:end-length(Trail))];
            end
            Outr3{nn} = tmps2;
        end

        %誤碼率統計在轉換為十進制之前計算
        [nberr1,rat1] = biterr(Outr3{1},Signal{1});
        [nberr1,rat2] = biterr(Outr3{2},Signal{2});
        [nberr1,rat3] = biterr(Outr3{3},Signal{3});
        [nberr1,rat4] = biterr(Outr3{4},Signal{4});
        [nberr1,rat5] = biterr(Outr3{5},Signal{5});

        Err_Rate0(jj2) = (rat1+rat2+rat3+rat4+rat5)/5;   
        Err_Rate1(jj2) = rat1;   
        Err_Rate2(jj2) = rat2;   
        Err_Rate3(jj2) = rat3;   
        Err_Rate4(jj2) = rat4;   
        Err_Rate5(jj2) = rat5;   
    end
    Err_Rate0s(Ind) = mean(Err_Rate0);
    Err_Rate1s(Ind) = mean(Err_Rate1);
    Err_Rate2s(Ind) = mean(Err_Rate2);
    Err_Rate3s(Ind) = mean(Err_Rate3);
    Err_Rate4s(Ind) = mean(Err_Rate4);
    Err_Rate5s(Ind) = mean(Err_Rate5);
    Q0(Ind)         = sqrt(2)*erfcinv(2*Err_Rate0s(Ind)/10);
    Q1(Ind)         = sqrt(2)*erfcinv(2*Err_Rate1s(Ind)/10);
    Q2(Ind)         = sqrt(2)*erfcinv(2*Err_Rate2s(Ind)/10);
    Q3(Ind)         = sqrt(2)*erfcinv(2*Err_Rate3s(Ind)/10);
    Q4(Ind)         = sqrt(2)*erfcinv(2*Err_Rate4s(Ind)/10);
    Q5(Ind)         = sqrt(2)*erfcinv(2*Err_Rate5s(Ind)/10);
    
    disp('over a cycle');
    pause(5);
end

figure;
semilogy(EbN0,Err_Rate0s,'b-^');
xlabel('EbN0');
ylabel('Ber');
grid on;

figure;
subplot(151);
semilogy(EbN0,Err_Rate1s,'b-^');
xlabel('EbN0');
ylabel('Ber');
title('子網1誤碼率');
grid on;
subplot(152);
semilogy(EbN0,Err_Rate2s,'b-^');
xlabel('EbN0');
ylabel('Ber');
title('子網2誤碼率');
grid on;
subplot(153);
semilogy(EbN0,Err_Rate3s,'b-^');
xlabel('EbN0');
ylabel('Ber');
title('子網3誤碼率');
grid on;
subplot(154);
semilogy(EbN0,Err_Rate4s,'b-^');
xlabel('EbN0');
ylabel('Ber');
title('子網4誤碼率');
grid on;
subplot(155);
semilogy(EbN0,Err_Rate5s,'b-^');
xlabel('EbN0');
ylabel('Ber');
title('子網5誤碼率');
grid on;



figure;
plot(EbN0,Q0,'b-o');
xlabel('EbN0');
ylabel('Q');
title('Q因子');
grid on;

4.仿真結論

眼圖仿真效果如下所示：c1.png, c2.png, c3.png

【光纖通信】光纖光栅傳感網接入GPON的matlab仿真

1.軟體版本

2.本算法理論知識

3.部分核心代碼

4.仿真結論

繼續閱讀

5G小型蜂應用指南

PAT (Advanced Level) Practise 1012 The Best Rank (25)

mysql5.7的sql優化

線程通信和程序通信差別（線程程序差別）

Matlab随機波動率SV、GARCH用MCMC馬爾可夫鍊蒙特卡羅方法分析匯率時間序列

微信小程式前端解密擷取使用者資訊

Spring MVC 自學雜記（五） -- SpringMVC與前台的json資料互動

《MySQL技術内幕：InnoDB存儲引擎》筆記

擴容TIKV節點遇到的坑

PHP輔導代做程式設計：CS353 Database System

RecycleView簡單的萬能擴充卡RecyclerView的萬能擴充卡

自學Zabbix3.10.2-事件通知Notifications upon events-Actions報警配置點選傳回：自學zabbix集錦

HDU 5678 ztr loves trees

拓端tecdat|R語言彈性網絡Elastic Net正則化懲罰回歸模型交叉驗證可視化

二叉樹及其應用--二叉樹建立

詳解STM32單片機的堆棧