diff --git a/Classes/01_transmit/Signalgenerator.m b/Classes/01_transmit/Signalgenerator.m index 6de1214..3062a07 100644 --- a/Classes/01_transmit/Signalgenerator.m +++ b/Classes/01_transmit/Signalgenerator.m @@ -1,12 +1,63 @@ classdef Signalgenerator - %NAME Summary of this class goes here - % Detailed explanation goes here + %SIGNALGENERATOR Generate simple information-level test sequences. + % + % This class creates Informationsignal objects for quick simulations, + % mapper checks, and theory scripts. Use the "form" option to select + % the generated sequence type. + % + % Examples: + % + % % Sine wave + % sig = Signalgenerator( ... + % "form", signalform.sine, ... + % "length", 1024, ... + % "fs", 1000, ... + % "fsig", 50).process(); + % + % % Deterministic random bit matrix, 2 bits per row + % bits = Signalgenerator( ... + % "form", signalform.random, ... + % "length", 1024, ... + % "dimension", 2, ... + % "randkey", 3).process(); + % + % % PRMS bit matrix for PAM-4 mapping. If length is omitted, the + % % output length is derived from order, as in the old PAMsource. + % bits = Signalgenerator( ... + % "form", signalform.prms, ... + % "dimension", 2, ... + % "order", 7).process(); + % symbols = PAMmapper(4, 0).map(bits); + % + % % PRMS for PAM-6: 5 bits map to 2 PAM-6 symbols + % bits = Signalgenerator( ... + % "form", signalform.prms, ... + % "dimension", 5, ... + % "order", 7).process(); + % bitVector = reshape(bits.signal.', [], 1); + % symbols = PAMmapper(6, 0).map(bitVector); + % + % % Map, demap, and check BER + % mapper = PAMmapper(8, 0); + % bits = Signalgenerator( ... + % "form", signalform.prms, ... + % "length", 1024, ... % explicit output length override + % "dimension", 3, ... + % "order", 5).process(); + % symbols = mapper.map(bits); + % rxBits = mapper.demap(symbols); + % [checkedBits, errors, ber] = calc_ber(rxBits, bits.signal); properties(Access=public) form length fs fsig + dimension + order + randkey + skip + bruijn end @@ -17,9 +68,14 @@ classdef Signalgenerator arguments options.form signalform = signalform.sine - options.length double = 1024 + options.length double = [] options.fs double = 1000 %Hz sampling options.fsig double = 50 % Hz fundamental frex e.g. of the sine or sawtooth + options.dimension double = 1 + options.order double = 7 + options.randkey double = 0 + options.skip double = 0 + options.bruijn logical = false end % @@ -30,6 +86,10 @@ classdef Signalgenerator end end + if isempty(obj.length) + obj.length = obj.default_length(); + end + end function signalclass_out = process(obj) @@ -69,7 +129,12 @@ classdef Signalgenerator % Generate sine wave signal = A * sin(2*pi*f*t); case signalform.noise - + s = RandStream('twister','Seed',obj.randkey); + signal = randn(s, 1, obj.length); + case signalform.random + signal = obj.build_random_data(); + case signalform.prms + signal = obj.build_prms_data(); end @@ -82,6 +147,317 @@ classdef Signalgenerator % Cant be seen from outside! So put all your functions here that can/ % shall not be called from outside + function signal = build_random_data(obj) + arguments(Input) + obj + end + + s = RandStream('twister','Seed',obj.randkey); + signal = randi(s, [0 1], obj.length, obj.dimension); + end + + %BUILD_PRMS_DATA Generate pseudo-random multi-level sequence bits. + % + % The output is a binary matrix with size: + % obj.length x obj.dimension + % + % Each row is one generated bit group / symbol time. Each column is + % one parallel PRMS bit stream. For conventional PAM formats this + % means: + % PAM-2: dimension = 1 + % PAM-4: dimension = 2 + % PAM-8: dimension = 3 + % + % PAM-6 is special in this codebase: the mapper consumes 5 bits and + % maps them to two PAM-6 symbols. Use dimension = 5, then flatten + % the output before calling PAMmapper(6, ...).map(...). + % + % Relevant Signalgenerator options: + % length Number of generated PRMS bit groups / rows. + % dimension Number of parallel bit streams per row. + % order User-facing sequence order, matching the old + % PAMsource behavior. If length is omitted, it sets the + % output length. Internally it is converted to the PRMS + % order per stream. + % Default output length is 2^(order-1), except for + % PAM-6-style dimension = 5 where it is 2^(order-2). + % skip Number of PRMS symbols to advance before output. This + % is useful when different blocks should use shifted + % sections of the same deterministic sequence. + % bruijn If true, enables de Bruijn-style zero-symbol insertion + % as in the legacy MOVE-IT generator. + % + % The implementation mirrors the legacy MOVE-IT/prms_c register + % logic in plain MATLAB, so no mex build is required. + + function signal = build_prms_data(obj) + arguments(Input) + obj + end + + obj.validate_prms_parameters(); + + state.dimension = obj.dimension; + state.order = obj.internal_prms_order(); + state.periodicity = state.dimension * state.order; + state.bl = obj.length; + state.bruijn = obj.bruijn; + state.bruijn_counter = -1; + state.srgtaps = Signalgenerator.srgtap_masks(state.periodicity); + mat_table = Signalgenerator.build_prms_mapping(state.dimension); + state.mat_table = mat_table * 2.^(0:state.dimension-1).'; + state.reg_mask = 2^state.periodicity - 1; + state.data_mask = 2^(state.periodicity - 1); + + tmp_reg = 2^49 - 1; + tmp_reg = Signalgenerator.advance_prbs_register(tmp_reg, state.srgtaps, 1, state.reg_mask); + state.reg = zeros(state.dimension, 1); + state.reg(1) = tmp_reg; + + modulo_mask = 2^state.dimension - 1; + offset = (2^state.periodicity - 1) / modulo_mask; + for n = 2:state.dimension + tmp_reg = Signalgenerator.advance_prbs_register(tmp_reg, state.srgtaps, offset, state.reg_mask); + state.reg(n) = tmp_reg; + end + + if obj.skip > 0 + state = Signalgenerator.advance_prms_state(state, obj.skip); + end + + [data_out, ~] = Signalgenerator.generate_prms_block(state, state.bl); + signal = data_out.'; + end + + function validate_prms_parameters(obj) + if obj.length < 1 || fix(obj.length) ~= obj.length + error("Signalgenerator:InvalidLength", ... + "PRMS length must be a positive integer."); + end + if obj.dimension < 1 || fix(obj.dimension) ~= obj.dimension + error("Signalgenerator:InvalidDimension", ... + "PRMS dimension must be a positive integer."); + end + if obj.order < 1 || fix(obj.order) ~= obj.order + error("Signalgenerator:InvalidOrder", ... + "PRMS order must be a positive integer."); + end + if obj.skip < 0 || fix(obj.skip) ~= obj.skip + error("Signalgenerator:InvalidSkip", ... + "PRMS skip must be a nonnegative integer."); + end + if obj.dimension * obj.internal_prms_order() > 48 + error("Signalgenerator:UnsupportedOrder", ... + "PRMS dimension * internal PRMS order must be <= 48."); + end + end + + function length = default_length(obj) + switch obj.form + case {signalform.random, signalform.prms} + if obj.dimension == 5 + length = 2^max(0, obj.order - 2); + else + length = 2^max(0, obj.order - 1); + end + otherwise + length = 1024; + end + end + + function prms_order = internal_prms_order(obj) + if obj.dimension == 5 + bits_per_symbol = log2(6); + else + bits_per_symbol = obj.dimension; + end + + prms_order = max(1, floor(obj.order / bits_per_symbol)); + end + end + + methods (Static, Access=private) + function state = advance_prms_state(state, number_symbols) + [~, state] = Signalgenerator.generate_prms_block(state, number_symbols); + end + + function [data_out, state] = generate_prms_block(state, block_length) + data_out = zeros(state.dimension, block_length); + counter = 0; + + while counter < block_length + if state.bruijn == 2 + counter = counter + 1; + state.bruijn = 1; + continue; + end + + for n = 1:state.dimension + prms_tmp_value = false; + for m = 1:state.dimension + prms_tmp_value = xor(prms_tmp_value, ... + state.reg(m) >= state.data_mask && ... + bitand(state.mat_table(m), 2^(n-1)) ~= 0); + end + data_out(n, counter + 1) = prms_tmp_value; + end + + for n = 1:state.dimension + state.reg(n) = Signalgenerator.advance_prbs_register( ... + state.reg(n), state.srgtaps, 1, state.reg_mask); + end + + counter = counter + 1; + + if state.bruijn == 1 + if state.bruijn_counter < 0 + if any([~sum(data_out(:, counter)) state.order == 1]) + state.bruijn_counter = state.bruijn_counter - 1; + if any([state.bruijn_counter == -state.order state.order == 1]) + state.bruijn_counter = 2^state.periodicity - 1; + state.bruijn = 2; + end + else + state.bruijn_counter = -1; + end + else + state.bruijn_counter = state.bruijn_counter - 1; + if state.bruijn_counter == 0 + state.bruijn_counter = 2^state.periodicity - 1; + state.bruijn = 2; + end + end + end + end + end + + function reg = advance_prbs_register(reg, tap_masks, number_steps, reg_mask) + for idx = 1:number_steps + feedback = false; + for tap_idx = 1:numel(tap_masks) + if tap_masks(tap_idx) ~= 0 + feedback = xor(feedback, bitand(reg, tap_masks(tap_idx)) ~= 0); + end + end + + reg = bitand(reg * 2 + double(feedback), reg_mask); + end + end + + function mat_table = build_prms_mapping(dimension) + if dimension > 2 + bchpolynomial = zeros(1, dimension + 1); + bchpolynomial([1 Signalgenerator.srgtaps(dimension) + 1]) = 1; + betatable = fliplr(Signalgenerator.cyclgen_local(2^dimension - 1, bchpolynomial).'); + elseif dimension == 2 + betatable = [0 1; 1 0; 1 1]; + else + betatable = 1; + end + + binvec = 2.^(dimension-1:-1:0); + modulo_mask = 2^dimension - 1; + betatable_sort_forward = sum(repmat(binvec, 2^dimension - 1, 1) .* betatable, 2); + [~, betatable_sort_inverse] = sort(betatable_sort_forward); + betatable_sort_inverse = betatable_sort_inverse - 1; + + dividend = zeros(dimension + 1, 2); + dividend([dimension - Signalgenerator.srgtaps(dimension) + 1 end], 1) = 1; + + h = zeros(dimension, 2); + for digit = 1:dimension + h(digit, 1:2) = dividend(digit, 1:2); + dividend(digit, 1:2) = [0 0]; + + newdiv_binary = xor( ... + betatable(dividend(digit + 1, 2) + 1, :) * dividend(digit + 1, 1), ... + betatable(rem(h(digit, 2) + 1, modulo_mask) + 1, :) * h(digit, 1)); + dividend(digit + 1, 1) = sum(newdiv_binary) > 0; + + if (digit ~= dimension) && dividend(digit + 1, 1) + dividend(digit + 1, 2) = dividend(digit + 1, 1) * ... + betatable_sort_inverse(sum(newdiv_binary .* binvec)); + else + dividend(digit + 1, 2) = 0; + end + end + + mat_table = betatable(h(:, 2) + 1, :); + end + + function code = cyclgen_local(columns, polynomial) + rows = log2(columns + 1); + code = zeros(rows, columns); + code(1, 1) = 1; + + for s = 2:columns + code(:, s) = [0; code(1:end-1, s-1)]; + + if code(end, s-1) + code(:, s) = rem(code(:, s) + polynomial(1:end-1).', 2); + end + end + end + + function taps = srgtaps(inx) + data = {[1] ... + [2 1] ... + [3 1] ... + [4 1] ... + [5 2] ... + [6 1] ... + [7 1] ... + [8 7 2 1] ... + [9 4] ... + [10 3] ... + [11 2] ... + [12 10 2 1] ... + [13 8 5 3] ... + [14 12 11 1] ... + [15 1] ... + [16 15 12 10] ... + [17 3] ... + [18 7] ... + [19 10 9 3] ... + [20 3] ... + [21 2] ... + [22 1] ... + [23 5] ... + [24 11 5 2] ... + [25 3] ... + [26 23 15 13] ... + [27 23 22 17] ... + [28 3] ... + [29 2] ... + [30 27 10 9] ... + [31 3] ... + [32 16 7 2] ... + [33 13] ... + [34 17 12 8] ... + [35 2] ... + [36 11] ... + [37 22 14 2] ... + [38 27 6 5] ... + [39 4] ... + [40 29 27 23] ... + [41 3] ... + [42 34 31 30] ... + [43 27 22 5] ... + [44 39 35 18] ... + [45 39 28 4] ... + [46 40 31 18] ... + [47 5] ... + [48 19 9 1]}; + + taps = data{inx}; + end + + function masks = srgtap_masks(inx) + taps = Signalgenerator.srgtaps(inx); + masks = zeros(1, 4); + masks(1:numel(taps)) = 2.^(taps - 1); + end + end end diff --git a/Datatypes/signalform.m b/Datatypes/signalform.m index b6a325b..f665e61 100644 --- a/Datatypes/signalform.m +++ b/Datatypes/signalform.m @@ -5,6 +5,8 @@ classdef signalform < int32 sawtooth (2) square (3) noise (4) + random (5) + prms (6) end -end \ No newline at end of file +end diff --git a/Libs/move_it/prms_move_it.m b/Libs/move_it/prms_move_it.m new file mode 100644 index 0000000..fe082ae --- /dev/null +++ b/Libs/move_it/prms_move_it.m @@ -0,0 +1,473 @@ +function [data_out ,state] = prms(data_in, state, para) + +global loop loopmax + +if nargin==0 + if loop==-1, + + % Abfrage der Ein- und Ausgnge + + noinp=0 ; + noout=1; + + % Zuordnung zu den Ausgangsvariablen + + data_out=noinp; + state=noout; + else + + % Parameterdefinition + + para.bl=128; + comment.bl='Block length (Length of output vector)'; + comment.short.bl='length'; + comment.type.bl='number'; + comment.level.bl=1; + + para.rand=0 ; + comment.rand='Random (True) or pseudo-random (False)'; + comment.short.rand='rand/prms'; + comment.type.rand='boolean'; + comment.level.rand=1; + + para.dimension=2; + comment.dimension='dimension (i.e. number of parallel bit streams)'; + comment.type.dimension='number'; + comment.short.dimension='dimension'; + comment.level.dimension=1; + + para.order=2; + comment.order='order of PRMS (needs to be adapted to memory of DUT)'; + comment.type.order='number'; + comment.short.order='order'; + comment.level.order=1; + + para.skip=0; + comment.skip='Skip the first n Bits of sequence'; + comment.type.skip='number'; + comment.short.skip='skip'; + comment.level.skip=1; + + para.bruijn=1; + comment.bruijn='extends the PRBS sequence of length 2^n-1 to a deBruijn sequence of 2^n'; + comment.type.bruijn='boolean'; + comment.short.bruijn='deBruijn'; + comment.level.bruijn=1; + + para.reset_prms=0; + comment.reset_prms='reset the sequence generator every loop'; + comment.type.reset_prms='boolean'; + comment.short.reset_prms='Reset every loop'; + comment.level.reset_prms=1; + + para.method=1; + comment.method='false= old method , true = new method'; + comment.type.method='Fast (c-file)|Slow (Matlab file)'; + comment.short.method='method'; + comment.level.method=1; + + data_out=para; + state=comment; + end; +else + + % Initialisierung + + if loop==0, + + % check for correct parameters + + checkskalar(getfield(inputname(2),{1:length(inputname(2))-6}),para,[{'bl'} {'skip'} {'dimension'} {'order'}],... + [{'length'} {'skip'} {'dimension'} {'order'}]); + checkinteger(getfield(inputname(2),{1:length(inputname(2))-6}),para,[{'bl'} {'skip'} {'dimension'} {'order'}],... + [{'length'} {'skip'} {'dimension'} {'order'}]); + checkpos(getfield(inputname(2),{1:length(inputname(2))-6}),para,[{'bl'} {'skip'} {'dimension'} {'order'}],... + [{'length'} {'skip'} {'dimension'} {'order'}]); + + % determine order of periodicity + % initializing of all state parameters + state.dimension = para.dimension; + state.order = para.order; + state.periodicity = para.dimension*para.order; + state.bl = para.bl; + + + state.reset_prms = para.reset_prms; + + if ~para.rand % PRMS + %------------------------------------------------------------------ + % prepare Matrix to map PRBS bits to PRMS values + %------------------------------------------------------------------ + + % create lookup-table for primitive element + if state.dimension>2, + % general case + bchpolynomial=zeros(1,state.dimension+1); + bchpolynomial([1 srgtaps(state.dimension)+1])=1; + betatable=fliplr(cyclgen_local(2^state.dimension-1,bchpolynomial).'); + + elseif state.dimension==2 + % special case, by-hand solution + betatable=[0 1;1 0;1 1]; + + elseif state.dimension==1 + % special case, by-hand solution + betatable=1; + + end; + binvec = 2.^(state.dimension-1:-1:0); + modulo_mask = 2^state.dimension-1; + betatable_sort_forward = sum(repmat(binvec,2^state.dimension-1,1).*betatable,2); + [dummy,betatable_sort_inverse] = sort(betatable_sort_forward); + betatable_sort_inverse = betatable_sort_inverse-1; + + % perform polynomial division by x+beta + + dividend=zeros(state.dimension+1,2); + dividend([state.dimension-srgtaps(state.dimension)+1 end],1)=1; + + h=zeros(state.dimension,2); + + for digit=1:state.dimension, + + % add new coefficient + + h(digit,1:2)=dividend(digit,1:2); + dividend(digit,1:2)=[0 0]; + + % update dividend + + newdiv_binary=xor(betatable(dividend(digit+1,2)+1,:)*dividend(digit+1,1),... + betatable(rem(h(digit,2)+1,modulo_mask)+1,:)*h(digit,1)); + dividend(digit+1,1)=sum(newdiv_binary)>0; + + % compute new dividend, exclude case of last iteration where + % dividend should end up with 0 + + if (digit~=state.dimension) && dividend(digit+1,1), + dividend(digit+1,2)=dividend(digit+1,1)*betatable_sort_inverse(sum(newdiv_binary.*binvec)); + else + dividend(digit+1,2)=0; + end; + end; + + % initialize the prms + + + % init parameters for deBruijn sequence + state.bruijn = para.bruijn; + state.bruijn_counter = -1; + + if para.method == 1, %new way + % Initialize the PRBS registers + tmp_srgtaps = srgtaps(state.periodicity); + state.srgtaps = zeros(4,1,'int64'); + + mat_table = betatable(h(:,2)+1,:); + state.mat_table = int64(mat_table * 2.^(0:state.dimension-1)'); + + for n=1:length(tmp_srgtaps) + state.srgtaps(n)=int64(2^(tmp_srgtaps(n)-1)); + end + + tmp_reg = int64(2^49-1); + + state.reg = zeros(state.dimension,1,'int64'); + tmp_reg = prms_c(int32(1),tmp_reg,state.srgtaps); + state.reg(1)= tmp_reg; + offset = (2^state.periodicity-1)/modulo_mask; + + for n=2:state.dimension + tmp_reg = prms_c(int32(offset),tmp_reg,state.srgtaps); + + state.reg(n)= tmp_reg; + end + + if para.skip>0 + [prbs_register, bruijn, bruijn_counter,data_out ]= prms_c(int32(para.skip),... + state.reg,... + state.srgtaps,... + int32(state.order),... + state.mat_table,... + int32(state.bruijn),... + int64(state.bruijn_counter)); + state.reg = prbs_register; + state.bruijn = bruijn; + state.bruijn_counter = bruijn_counter; + end + + else + % Initialize the PRBS registers + state.reg = ones(1,state.periodicity); + state.srgtaps = srgtaps(state.periodicity); + + state.mat_table = betatable(h(:,2)+1,:); + + % determine indices into past PRBS + + state.PRBS_inx=1+(0:state.dimension-1)*(2^state.periodicity-1)/modulo_mask; + + % fill PRBS_memory by creating the first part of the PRBS + [state.reg,state.PRBS_memory]=prms_prbs_init_mex(state.periodicity,state.srgtaps,state.PRBS_inx(end)); + % init for deBruijn sequence + + % skip first bits + skipped=0; + PRBS_memory_pointer=0; + while skipped1, + skipped = skipped+1; + state.bruijn = 1; + continue; + end; + + % compute current PRMS-symbol + + PRBS_inx=mod(state.PRBS_inx+PRBS_memory_pointer-1,state.PRBS_inx(end))+1; + symbol_temp=rem(sum(repmat(double(state.PRBS_memory(PRBS_inx).'),1,state.dimension).*... + state.mat_table,1),2).'; + + % compute new PRBS_memory + + state.reg=[rem(sum(state.reg(state.srgtaps)),2) state.reg(1:end-1)]; + state.PRBS_memory(PRBS_memory_pointer+1)=state.reg(end); + + PRBS_memory_pointer=mod(PRBS_memory_pointer+1,state.PRBS_inx(end)); + skipped=skipped+1; + + % consider deBruijn option + + if state.bruijn==1, + if state.bruijn_counter<0, + % counter not yet locked + if any([~sum(symbol_temp) state.order==1]), + % zero symbol detected + state.bruijn_counter=state.bruijn_counter-1; + if any([state.bruijn_counter== -state.order state.order==1]), + % lock counter + state.bruijn_counter=2^state.periodicity-1; + state.bruijn=2; + end; + else + % no zero, so reset counter + state.bruijn_counter=-1; + end; + else + % counter already locked + state.bruijn_counter=state.bruijn_counter-1; + if state.bruijn_counter==0, + % reset counter + state.bruijn_counter = 2^state.periodicity-1; + state.bruijn=2; + end; + end; + end; + end; + end; + + end + + data_out=zeros(state.dimension,state.bl); + + else + + % Execution Stage + + % update status window + + % status(getfield(inputname(2),{1:length(inputname(2))-6})); + + bl = state.bl; + + if ~para.rand % PRMS + + if para.method == 1 % fast implementation + + [prbs_register, bruijn, bruijn_counter,data_out ]= prms_c(int32(state.bl),... + state.reg,... + state.srgtaps,... + int32(state.order),... + state.mat_table,... + int32(state.bruijn),... + int64(state.bruijn_counter)); + if ~state.reset_prms + state.reg = prbs_register; + state.bruijn = bruijn; + state.bruijn_counter = bruijn_counter; + end + + data_out = double(data_out); + + else %old way slow implementation + + if ((loop==1) || ~state.reset_prms) + % Initialisierung des Ausgangsvektors + data_out = zeros(state.dimension,bl); + + % Successives Berechnen der Ausgangsfolge + counter=0; + PRBS_memory_pointer=0; + + while counter PAMmapper -> demap -> BER + +clear; clc; + +repoRoot = fileparts(fileparts(fileparts(mfilename("fullpath")))); +addpath(genpath(repoRoot)); + +orders = [2 4 6 8]; +userOrder = 7; + +fprintf("PAM | bits checked | errors | BER\n"); +fprintf("----+--------------+--------+-----\n"); + +for M = orders + if M == 6 + bitsPerBlock = 5; + else + bitsPerBlock = log2(M); + end + + bitSignal = Signalgenerator( ... + "form", signalform.prms, ... + "dimension", bitsPerBlock, ... + "order", userOrder).process(); + + if M == 6 + txBits = reshape(bitSignal.signal.', [], 1); + txBits = txBits(1:end - mod(numel(txBits), bitsPerBlock)); + else + txBits = bitSignal.signal; + end + + mapper = PAMmapper(M, 0); + txSymbols = mapper.map(txBits); + rxBits = mapper.demap(txSymbols); + + [checkedBits, errors, ber] = calc_ber(rxBits, txBits); + + fprintf("%3d | %12d | %6d | %.1e\n", M, checkedBits, errors, ber); +end diff --git a/projects/Messung_Zürich/Prep_Meeting.pptx b/projects/Messung_Zürich/Prep_Meeting.pptx new file mode 100644 index 0000000..d67aa8f Binary files /dev/null and b/projects/Messung_Zürich/Prep_Meeting.pptx differ diff --git a/projects/Messung_Zürich/aliasing.svg b/projects/Messung_Zürich/aliasing.svg new file mode 100644 index 0000000..3417f3e --- /dev/null +++ b/projects/Messung_Zürich/aliasing.svg @@ -0,0 +1,287 @@ + + + diff --git a/projects/Messung_Zürich/equalization.pptx b/projects/Messung_Zürich/equalization.pptx new file mode 100644 index 0000000..b8a1c17 Binary files /dev/null and b/projects/Messung_Zürich/equalization.pptx differ diff --git a/projects/Messung_Zürich/freqresp_mzm.fig b/projects/Messung_Zürich/freqresp_mzm.fig new file mode 100644 index 0000000..6adfa18 Binary files /dev/null and b/projects/Messung_Zürich/freqresp_mzm.fig differ diff --git a/projects/Messung_Zürich/freqresp_mzm.svg b/projects/Messung_Zürich/freqresp_mzm.svg new file mode 100644 index 0000000..80e851c --- /dev/null +++ b/projects/Messung_Zürich/freqresp_mzm.svg @@ -0,0 +1,154 @@ + + + diff --git a/projects/Messung_Zürich/psd.svg b/projects/Messung_Zürich/psd.svg new file mode 100644 index 0000000..1da0bf3 --- /dev/null +++ b/projects/Messung_Zürich/psd.svg @@ -0,0 +1,379 @@ + + + diff --git a/projects/Messung_Zürich/taps_pam8.fig b/projects/Messung_Zürich/taps_pam8.fig new file mode 100644 index 0000000..f24d9ea Binary files /dev/null and b/projects/Messung_Zürich/taps_pam8.fig differ