image transmission and reception using 802.11 waveform and sdr -凯发k8网页登录

channel = "gaussiannoise";
if strcmpi(channel,"overtheair")
    devicename = "pluto";
    channelnumber = 5;
    frequencyband = 2.4;
    txgain = -10;
    rxgain = 10;
elseif strcmpi(channel,"gaussiannoise")
    % specify snr of received signal for a simulated channel 
    snr = 20;
end

% setup handle for image plot
if ~exist('imfig','var') || ~ishandle(imfig) %#ok 
    imfig = figure;
    imfig.numbertitle = 'off';
    imfig.name = 'image plot';
    imfig.visible = 'off';
else
    clf(imfig); % clear figure
    imfig.visible = 'off';
end
% setup spectrum viewer
spectrumscope = spectrumanalyzer( ...
    spectrumtype='power-density', ...
    title='received baseband wlan signal spectrum', ...
    ylabel='power spectral density', ...
    position=[69 376 800 450]);
% setup the constellation diagram viewer for equalized wlan symbols
refqam = wlanreferencesymbols('64qam');
constellation = comm.constellationdiagram(...
    title='equalized wlan symbols',...
    showreferenceconstellation=true,...
    referenceconstellation=refqam,...
    position=[878 376 460 460]);

% input an image file and convert to binary stream
filetx = 'peppers.png';                   % image file name
fdata = imread(filetx);                          % read image data from file
scale = 0.2;                    % image scaling factor
origsize = size(fdata);                          % original input image size
scaledsize = max(floor(scale.*origsize(1:2)),1); % calculate new image size
heightix = min(round(((1:scaledsize(1))-0.5)./scale 0.5),origsize(1));
widthix = min(round(((1:scaledsize(2))-0.5)./scale 0.5),origsize(2));
fdata = fdata(heightix,widthix,:);               % resize image
imsize = size(fdata);                            % store new image size
tximage = fdata(:);
% plot transmit image
imfig.visible = 'on';
subplot(211);
imshow(fdata);
title('transmitted image');
subplot(212);
title('received image appears here...');
set(gca,'visible','off');

set(findall(gca, 'type', 'text'), 'visible', 'on');

msdulength = 2304; % msdu length in bytes
nummsdus = ceil(length(tximage)/msdulength);
padzeros = msdulength-mod(length(tximage),msdulength);
txdata = [tximage;zeros(padzeros,1)];
txdatabits = double(int2bit(txdata,8,false));
% divide input data stream into fragments
bitsperoctet = 8;
data = zeros(0,1);
for i=0:nummsdus-1
    % extract image data (in octets) for each mpdu
    framebody = txdata(i*msdulength 1:msdulength*(i 1),:);
    % create mac frame configuration object and configure sequence number
    cfgmac = wlanmacframeconfig(frametype='data',sequencenumber=i);
    % generate mpdu
    [psdu, lengthmpdu]= wlanmacframe(framebody,cfgmac,outputformat='bits');
    % concatenate psdus for waveform generation
    data = [data; psdu]; %#ok
end

nonhtcfg = wlannonhtconfig;       % create packet configuration
nonhtcfg.mcs = 6;                 % modulation: 64qam rate: 2/3
nonhtcfg.numtransmitantennas = 1; % number of transmit antenna
chanbw = nonhtcfg.channelbandwidth;
nonhtcfg.psdulength = lengthmpdu; % set the psdu length

scramblerinitialization = randi([1 127],nummsdus,1);

osf = 1.5;
samplerate = wlansamplerate(nonhtcfg); % nominal sample rate in hz
% generate baseband nonht packets separated by idle time
txwaveform = wlanwaveformgenerator(data,nonhtcfg, ...
    numpackets=nummsdus,idletime=20e-6, ...
    scramblerinitialization=scramblerinitialization,...
    oversamplingfactor=osf);

if strcmpi(channel,"overtheair")
    % transmitter properties
    sdrtransmitter = sdrtx(devicename);
    sdrtransmitter.basebandsamplerate = samplerate*osf;
    sdrtransmitter.centerfrequency = wlanchannelfrequency(channelnumber,frequencyband);
    sdrtransmitter.gain = txgain;
    
    % pass the sdr i/o directly to host skipping fpga on zynq radio or usrp
    % embedded series radio
    if ~strcmpi(devicename,"pluto")
        sdrtransmitter.showadvancedproperties = true;
        sdrtransmitter.bypassuserlogic = true;
    end
    fprintf('\ngenerating wlan transmit waveform:\n')
    % scale the normalized signal to avoid saturation of rf stages
    powerscalefactor = 0.8;
    txwaveform = txwaveform.*(1/max(abs(txwaveform))*powerscalefactor);
    % transmit rf waveform
    transmitrepeat(sdrtransmitter,txwaveform);
end

if strcmpi(channel,"overtheair")
    sdrreceiver = sdrrx(devicename);
    sdrreceiver.basebandsamplerate = sdrtransmitter.basebandsamplerate;
    sdrreceiver.centerfrequency = sdrtransmitter.centerfrequency;
    sdrreceiver.outputdatatype = 'double';
    sdrreceiver.gainsource = 'manual';
    sdrreceiver.gain = rxgain;
    if ~strcmpi(devicename,"pluto")
        sdrreceiver.showadvancedproperties = true;
        sdrreceiver.bypassuserlogic = true;
    end
    % configure the capture length equivalent to twice the length of the
    % transmitted signal, this is to ensure that psdus are received in order.
    % on reception the duplicate mac fragments are removed.
    sdrreceiver.samplesperframe = 2*length(txwaveform);
    fprintf('\nstarting a new rf capture.\n')
    rxwaveform = capture(sdrreceiver,sdrreceiver.samplesperframe,'samples');
elseif strcmpi(channel,"gaussiannoise")
    rxwaveform = awgn(txwaveform,snr,'measured');
else % no impairments
    rxwaveform = txwaveform;
end

spectrumscope.samplerate = samplerate*osf;
spectrumscope(rxwaveform);
release(spectrumscope);

astop = 40; % stopband attenuation
ofdminfo = wlannonhtofdminfo('nonht-data',nonhtcfg); % ofdm parameters
scs = samplerate/ofdminfo.fftlength; % subcarrier spacing
txbw = max(abs(ofdminfo.activefrequencyindices))*2*scs; % occupied bandwidth
[l,m] = rat(1/osf);
maxlm = max([l m]);
r = (samplerate-txbw)/samplerate;
tw = 2*r/maxlm; % transition width
b = designmultiratefir(l,m,tw,astop);

firrc = dsp.firrateconverter(l,m,b);
rxwaveform = firrc(rxwaveform);

displayflag = false; 

rxwaveformlen = size(rxwaveform,1);
searchoffset = 0; % offset from start of the waveform in samples

ind = wlanfieldindices(nonhtcfg);
ns = ind.lsig(2)-ind.lsig(1) 1; % number of samples in an ofdm symbol
% minimum packet length is 10 ofdm symbols
lstflen = double(ind.lstf(2)); % number of samples in l-stf
minpktlen = lstflen*5;
pktind = 1;
finetimingoffset = [];
packetseq = [];
rxbit = [];
% perform evm calculation
evmcalculator = comm.evm(averagingdimensions=[1 2 3]);
evmcalculator.maximumevmoutputport = true;

while (searchoffset minpktlen)<=rxwaveformlen
    % packet detect
    pktoffset = wlanpacketdetect(rxwaveform,chanbw,searchoffset,0.5);
    % adjust packet offset
    pktoffset = searchoffset pktoffset;
    if isempty(pktoffset) || (pktoffset double(ind.lsig(2))>rxwaveformlen)
        if pktind==1
            disp('** no packet detected **');
        end
        break;
    end
    % extract non-ht fields and perform coarse frequency offset correction
    % to allow for reliable symbol timing
    nonht = rxwaveform(pktoffset (ind.lstf(1):ind.lsig(2)),:);
    coarsefreqoffset = wlancoarsecfoestimate(nonht,chanbw);
    nonht = frequencyoffset(nonht,samplerate,-coarsefreqoffset);
    % symbol timing synchronization
    finetimingoffset = wlansymboltimingestimate(nonht,chanbw);
    % adjust packet offset
    pktoffset = pktoffset finetimingoffset;
    % timing synchronization complete: packet detected and synchronized
    % extract the non-ht preamble field after synchronization and
    % perform frequency correction
    if (pktoffset<0) || ((pktoffset minpktlen)>rxwaveformlen)
        searchoffset = pktoffset 1.5*lstflen;
        continue;
    end
    fprintf('\npacket-%d detected at index %d\n',pktind,pktoffset 1);
    % extract first 7 ofdm symbols worth of data for format detection and
    % l-sig decoding
    nonht = rxwaveform(pktoffset (1:7*ns),:);
    nonht = frequencyoffset(nonht,samplerate,-coarsefreqoffset);
    % perform fine frequency offset correction on the synchronized and
    % coarse corrected preamble fields
    lltf = nonht(ind.lltf(1):ind.lltf(2),:);           % extract l-ltf
    finefreqoffset = wlanfinecfoestimate(lltf,chanbw);
    nonht = frequencyoffset(nonht,samplerate,-finefreqoffset);
    cfocorrection = coarsefreqoffset finefreqoffset; % total cfo
    % channel estimation using l-ltf
    lltf = nonht(ind.lltf(1):ind.lltf(2),:);
    demodlltf = wlanlltfdemodulate(lltf,chanbw);
    chanestlltf = wlanlltfchannelestimate(demodlltf,chanbw);
    % noise estimation
    noisevarnonht = wlanlltfnoiseestimate(demodlltf);
    % packet format detection using the 3 ofdm symbols immediately
    % following the l-ltf
    format = wlanformatdetect(nonht(ind.lltf(2) (1:3*ns),:), ...
        chanestlltf,noisevarnonht,chanbw);
    disp(['  ' format ' format detected']);
    if ~strcmp(format,'non-ht')
        fprintf('  a format other than non-ht has been detected\n');
        searchoffset = pktoffset 1.5*lstflen;
        continue;
    end
    % recover l-sig field bits
    [reclsigbits,failcheck] = wlanlsigrecover( ...
        nonht(ind.lsig(1):ind.lsig(2),:), ...
        chanestlltf,noisevarnonht,chanbw);
    if failcheck
        fprintf('  l-sig check fail \n');
        searchoffset = pktoffset 1.5*lstflen;
        continue;
    else
        fprintf('  l-sig check pass \n');
    end
    % retrieve packet parameters based on decoded l-sig
    [lsigmcs,lsiglen,rxsamples] = helperinterpretlsig(reclsigbits,samplerate);
    if (rxsamples pktoffset)>length(rxwaveform)
        disp('** not enough samples to decode packet **');
        break;
    end
    % apply cfo correction to the entire packet
    rxwaveform(pktoffset (1:rxsamples),:) = frequencyoffset(...
        rxwaveform(pktoffset (1:rxsamples),:),samplerate,-cfocorrection);
    % create a receive non-ht config object
    rxnonhtcfg = wlannonhtconfig;
    rxnonhtcfg.mcs = lsigmcs;
    rxnonhtcfg.psdulength = lsiglen;
    % get the data field indices within a ppdu
    indnonhtdata = wlanfieldindices(rxnonhtcfg,'nonht-data');
    % recover psdu bits using transmitted packet parameters and channel
    % estimates from l-ltf
    [rxpsdu,eqsym] = wlannonhtdatarecover(rxwaveform(pktoffset ...
        (indnonhtdata(1):indnonhtdata(2)),:), ...
        chanestlltf,noisevarnonht,rxnonhtcfg);
    constellation(reshape(eqsym,[],1)); % current constellation
    release(constellation);
    refsym = wlanclosestreferencesymbol(eqsym,rxnonhtcfg);
    [evm.rms,evm.peak] = evmcalculator(refsym,eqsym);
    % decode the mpdu and extract msdu
    [cfgmacrx,msdulist{pktind},status] = wlanmpdudecode(rxpsdu,rxnonhtcfg); %#ok<*sagrow>
    if strcmp(status,'success')
        disp('  mac fcs check pass');
        % store sequencing information
        packetseq(pktind) = cfgmacrx.sequencenumber;
        % convert msdu to a binary data stream
        rxbit{pktind} = int2bit(hex2dec(cell2mat(msdulist{pktind})),8,false);
    else % decoding failed
        if strcmp(status,'fcsfailed')
            % fcs failed
            disp('  mac fcs check fail');
        else
            % fcs passed but encountered other decoding failures
            disp('  mac fcs check pass');
        end
        % since there are no retransmissions modeled in this example, we
        % extract the image data (msdu) and sequence number from the mpdu,
        % even though fcs check fails.
        % remove header and fcs. extract the msdu.
        macheaderbitslength = 24*bitsperoctet;
        fcsbitslength = 4*bitsperoctet;
        msdulist{pktind} = rxpsdu(macheaderbitslength 1:end-fcsbitslength);
        % extract and store sequence number
        sequencenumstartindex = 23*bitsperoctet 1;
        sequencenumendindex = 25*bitsperoctet-4;
        conversionlength = sequencenumendindex-sequencenumstartindex 1;
        packetseq(pktind) = bit2int(rxpsdu(sequencenumstartindex:sequencenumendindex),conversionlength,false);
        % msdu binary data stream
        rxbit{pktind} = double(msdulist{pktind});
    end
    % display decoded information
    if displayflag
        fprintf('  estimated cfo: %5.1f hz\n\n',cfocorrection); %#ok<*unrch> 
        disp('  decoded l-sig contents: ');
        fprintf('                            mcs: %d\n',lsigmcs);
        fprintf('                         length: %d\n',lsiglen);
        fprintf('    number of samples in packet: %d\n\n',rxsamples);
        fprintf('  evm:\n');
        fprintf('    evm peak: %0.3f%%  evm rms: %0.3f%%\n\n', ...
            evm.peak,evm.rms);
        fprintf('  decoded mac sequence control field contents:\n');
        fprintf('    sequence number: %d\n\n',packetseq(pktind));
    end
    % update search index
    searchoffset = pktoffset double(indnonhtdata(2));
    
    % finish processing when a duplicate packet is detected. the
    % recovered data includes bits from duplicate frame
    % remove the data bits from the duplicate frame
    if length(unique(packetseq)) < length(packetseq)
        rxbit = rxbit(1:length(unique(packetseq)));
        packetseq = packetseq(1:length(unique(packetseq)));
        break
    end
    pktind = pktind 1;
end

if strcmpi(channel,"overtheair")
    release(sdrtransmitter);
    release(sdrreceiver);
end

if ~(isempty(finetimingoffset) || isempty(pktoffset))
    % convert decoded bits from cell array to column vector
    rxdata = cat(1,rxbit{:});
    % remove any extra bits
    rxdata = rxdata(1:end-(mod(length(rxdata),msdulength*8)));
    % reshape such that each column length has bits equal to msdulength*8
    rxdata = reshape(rxdata,msdulength*8,[]);
    % remove duplicate packets if any. duplicate packets are located at the
    % end of rxdata
    if length(packetseq)>nummsdus
        numduppackets = size(rxdata,2)-nummsdus;
        rxdata = rxdata(:,1:end-numduppackets);
    end
    % initialize variables for while loop
    startseq = [];
    i=-1;
    % only execute this if one of the packet sequence values have been decoded
    % accurately
    if any(packetseqwhile isempty(startseq)
            % this searches for a known packetseq value
            i = i   1;
            startseq = find(packetseq==i);
        end
        % circularly shift data so that received packets are in order for image reconstruction. it
        % is assumed that all packets following the starting packet are received in
        % order as this is how the image is transmitted.
        rxdata = circshift(rxdata,[0 -(startseq(1)-i-1)]); % order mac fragments
        % perform bit error rate (ber) calculation on reordered data
        biterrorrate = comm.errorrate;
        err = biterrorrate(double(rxdata(:)), ...
            txdatabits(1:length(reshape(rxdata,[],1))));
        fprintf('  \nbit error rate (ber):\n');
        fprintf('          bit error rate (ber) = %0.5f\n',err(1));
        fprintf('          number of bit errors = %d\n',err(2));
        fprintf('    number of transmitted bits = %d\n\n',length(txdatabits));
    end
    decdata = bit2int(reshape(rxdata(:),8,[]),8,false)';
    % append nans to fill any missing image data
    if length(decdata)else
        decdata = decdata(1:length(tximage));
    end
    % recreate image from received data
    fprintf('\nconstructing image from received data.\n');
    receivedimage = uint8(reshape(decdata,imsize));
    % plot received image
    if exist('imfig','var') && ishandle(imfig) % if tx figure is open
        figure(imfig); subplot(212);
    else
        figure; subplot(212);
    end
    imshow(receivedimage);
    title(sprintf('received image'));
end