function[w l2] = chCoding(c, F, l)

%% Kanálové kódování
% Úkolem kanálového kódování je ochran přenášené informace. Ke kódování je
% použit turbokodér.


%% Upravení vstupní posloupnosti
% Slouží k úpravě vstupní posloupnosti, ale jelikož jsou plnící bity
% nastaveny na 0, není úprava nutná.

%% Kódování
% index slouží jako ukazatel na začátek datového bloku
index = 0;index2 = 0;
l2 = zeros(length(l),1);      % délky bloků po kódování a prokládání

% konstanty
trellis = poly2trellis(4, [13 15], 13); % Struktura koderu


if(length(l) >= 1),
    for i = 1:length(l),
        
        d_temp = c(index+1:index + l(i));

        % Prokládání
        [c_ i_] = InternalInterleavingTurbo(c(index+1:index + l(i)));
            hTEnc  = comm.TurboEncoder('TrellisStructure', trellis...
             , 'InterleaverIndices', i_);
            encodedData = step(hTEnc, d_temp); 
            a_ = reshape(encodedData,3,length(encodedData)/3)';
            dk_0 = a_(:,1);
            dk_1 = a_(:,2);
            dk_2 = a_(:,3);
        % Sub-block prokladani 5.1.4.1.1 - 3GPP TS 36.212 V8.8.0 str. 15
        D = length(dk_0);   % Počet bitů v bloku
        C_TC_subblock = 32; % Počet sloupců matice
        R_TC_subblock = ceil(D/C_TC_subblock);  % Počet řádků matice, zaokrouhlený nahoru na celá čísla
        Nd = (R_TC_subblock*C_TC_subblock) - D; % Počet plnících bitů
        % Vytvoření matice
        y_dk_0 = reshape([zeros(Nd,1); dk_0],R_TC_subblock,C_TC_subblock)';
        y_dk_1 = reshape([zeros(Nd,1); dk_1],R_TC_subblock,C_TC_subblock)';
        y_dk_2 = reshape([zeros(Nd,1); dk_2],C_TC_subblock,R_TC_subblock);

        
        % Přeskládání sloupců matice a vytvoření posloupnosti vk_0 a vk_1, platné pouze pro vstupy dk_0 a dk_1
        K_pi = C_TC_subblock*R_TC_subblock;
        P = [0 16 8 24 4 20 12 28 2 18 10 26 6 22 14 30 1 17 9 25 5 21 13 29 3 19 11 27 7 23 15 31];
        yP_dk_0 = zeros(size(y_dk_0,1),size(y_dk_0,2));
        yP_dk_1 = zeros(size(y_dk_1,1),size(y_dk_1,2));
        for i2 = 1:C_TC_subblock,
            yP_dk_0(P(i2)+1,:) = y_dk_0(i2,:);
            yP_dk_1(P(i2)+1,:) = y_dk_1(i2,:);
        end
        
        vk_0 = reshape(yP_dk_0,K_pi,1);
        vk_1 = reshape(yP_dk_1,K_pi,1);
        % Vytvoření posloupnosti pro vk_2, platí pouze pro dk_2
        y_dk_2 = reshape(y_dk_2, 1, K_pi)';
        vk_2 = zeros(length(vk_1),1);
        for k = 0:(K_pi-1),
            vk_2(k+1) = y_dk_2(mod(P((floor(k/R_TC_subblock)+1))+ C_TC_subblock*mod(k,R_TC_subblock)+1,K_pi)+1);
        end
        
        wk = zeros(3*K_pi,1);
        wk(1:K_pi) = vk_0;
        for i3 = 1:K_pi,
            wk(K_pi +2*i3 -1) = vk_1(i3);
            wk(K_pi +2*i3) = vk_2(i3);
        end
        l2(i) = length(wk);
        %% Code block concatention
        w(index2+1:index2 + l2(i)) = wk;
        % Zvýšení indexu
        index = index + l(i);
        index2 = index2 + l2(i);
    end
else
    display('Chyba v chCoding, proměnná l neobsahuje informace o délce bloků');
end

%% kontrola správnosti dekódování
% index = 0;
% index2 = 0;
%  
% 
% if(length(l2) >= 1),
%     for i = 1:length(l2),
%         % rozdělení toku do bloků
%         K_pi_ = l2(i)/3;
%         wk = e(index2+1:index2 + l2(i));
%         vk_0_ = zeros(K_pi_,1); vk_1_ = zeros(K_pi_,1); vk_2_ = zeros(K_pi_,1);
%         vk_0_ = wk(1:K_pi_)';
%         for i2 = 1:K_pi_,
%             vk_1_(i2) = wk(K_pi_ +2*i2 -1);
%             vk_2_(i2) = wk(K_pi_ +2*i2);
%         end
%         
%                 % Sub-block prokladani 5.1.4.1.1 - 3GPP TS 36.212 V8.8.0 str. 15
%         D_ = l(i);   % Počet bitů v bloku
%         C_TC_subblock_ = 32; % Počet sloupců matice
%         R_TC_subblock_ = ceil(D_/C_TC_subblock_);  % Počet řádků matice, zaokrouhlený nahoru na celá čísla
%         Nd_ = (R_TC_subblock_*C_TC_subblock_) - D_; % Počet plnících bitů        
%         P_ = [0 16 8 24 4 20 12 28 2 18 10 26 6 22 14 30 1 17 9 25 5 21 13 29 3 19 11 27 7 23 15 31];
%         y_dk_2_ = zeros(K_pi,1);
%         for k = 0:(K_pi_-1),
%             y_dk_2_(mod(P_((round(k/R_TC_subblock_+0.5)))+ C_TC_subblock_*mod(k,R_TC_subblock_)+1,K_pi_)+1) = vk_2_(k+1);
%         end
% 
%         yP_dk_0_ = reshape(vk_0_,C_TC_subblock_,R_TC_subblock_);
%         yP_dk_1_ = reshape(vk_1_,C_TC_subblock_,R_TC_subblock_);
%         
%         y_dk_0_ = zeros(size(yP_dk_0_,1),size(yP_dk_0_,2));
%         y_dk_1_ = zeros(size(yP_dk_1_,1),size(yP_dk_1_,2));
%         for i3 = 1:C_TC_subblock,
%             y_dk_0_(P_(i3)+1,:) = yP_dk_0_(i3,:);
%             y_dk_1_(P_(i3)+1,:) = yP_dk_1_(i3,:);
%         end
%         dk_0_ = reshape(y_dk_0_',K_pi_,1);dk_0_ = dk_0_(Nd+1:K_pi_);
%         dk_1_ = reshape(y_dk_1_',K_pi_,1);dk_1_ = dk_1_(Nd+1:K_pi_);
%         dk_2_ = y_dk_2_;
%         dk_2_ = dk_2_(Nd+1:K_pi_);
%         
%         index2 = index2 + l2(i);
%         
%         % První dekodér
%         c_1_ = vitdec(dk_1_,trellis,7,'trunc', 'hard');
%         % Druhý dekodér
%         c_2_ = vitdec(dk_2_,trellis,7,'trunc', 'hard');
%         % Prokládání
%         c_deInt_ = InternalDeInterleavingTurbo(c_2_);
%         % seskupení
%         c__(index+1:index + l(i)) = dk_0_;
%         c_1__(index+1:index + l(i)) = c_1_;
%         c_2__(index+1:index + l(i)) = c_deInt_;
%         % Zvýšení indexu
%         index = index + l(i);
%     end
%     asshole = sum(c-c__');
%     test = issame(c,c__')
% end