VNA_dummy.py

#!/usr/bin/python3
import shared_simulated_state
import math
import climate_chamber_dummy

VNA_dummy_instance = None


def get_vna_dummy(target_accuracy):
    global VNA_dummy_instance
    if VNA_dummy_instance is None:
        VNA_dummy_instance = VnaDummy(target_accuracy)
    return VNA_dummy_instance


class VnaDummy:
    def __init__(self, target_accuracy):
        self.target_accuracy = target_accuracy

        # store the credentials so that methods can access them

        # Simulated Variables
        self.simulated_traces = [('Trc1', 's11')]
        self.result_format = 'SDAT'
        self.simulated_power = '10.dBm'
        self.simulated_frequency = '10.MHz'
        self.simulated_magnitude_difference_temp = 0.0
        self.simulated_phase_difference_temp = 0.0
        self.simulated_magnitude_difference_hum = 0.0
        self.simulated_phase_difference_hum = 0.0
        self.simulated_state = shared_simulated_state.get_simulated_state()
        self.last_simulated_time = self.simulated_state.simulated_time
        self.tau_mag_temp = 25     # change rate of magnitude in dependence on temperature
        self.tau_phase_temp = 35   # change rate of phase in dependence on temperature
        self.tau_mag_hum = 250     # change rate of magnitude in dependence on humidity
        self.tau_phase_hum = 350   # change rate of phase in dependence on humidity
        self.reference_magnitude = 0.7  # at reference temp and reference hum
        self.reference_phase = 70  # at reference temp and reference hum
        self.reference_temp = 25
        self.reference_hum = 35
        self.magnitude_slope_temp = -0.02
        self.magnitude_slope_hum = -0.018
        self.phase_slope_temp = 0.1
        self.phase_slope_hum = -0.15
        self.communication_delay = 0.2

    def run_simulation(self):
        self.simulate_magnitude()
        self.simulate_phase()
        self.last_simulated_time = self.simulated_state.simulated_time

    def simulate_magnitude(self):

        target_magnitude_difference_temp = self.magnitude_slope_temp * \
                                           (self.simulated_state.simulated_temperature - self.reference_temp)
        delta_magnitude_temp = target_magnitude_difference_temp - self.simulated_magnitude_difference_temp

        target_magnitude_difference_hum = self.magnitude_slope_hum * \
                                          (self.simulated_state.simulated_humidity - self.reference_hum)
        delta_magnitude_hum = target_magnitude_difference_hum - self.simulated_magnitude_difference_hum

        delta_time = self.simulated_state.simulated_time - self.last_simulated_time

        self.simulated_magnitude_difference_temp = self.simulated_magnitude_difference_temp + \
                                                   delta_magnitude_temp * \
                                                   (1 - (math.exp(-1. * delta_time / self.tau_mag_temp)))
        self.simulated_magnitude_difference_hum = self.simulated_magnitude_difference_hum + \
                                                   delta_magnitude_hum * \
                                                   (1 - (math.exp(-1. * delta_time / self.tau_mag_hum)))


    def simulate_phase(self):

        target_phase_difference_temp = self.phase_slope_temp * \
                                       (self.simulated_state.simulated_temperature - self.reference_temp)
        delta_phase_temp = target_phase_difference_temp - self.simulated_phase_difference_temp
        target_phase_difference_hum = self.phase_slope_hum * \
                                       (self.simulated_state.simulated_humidity - self.reference_hum)
        delta_phase_hum = target_phase_difference_hum - self.simulated_phase_difference_hum

        delta_time = self.simulated_state.simulated_time - self.last_simulated_time

        self.simulated_phase_difference_temp = self.simulated_phase_difference_temp + \
                                               delta_phase_temp *\
                                               (1 - (math.exp(-1. * delta_time / self.tau_phase_temp)))
        self.simulated_phase_difference_hum = self.simulated_phase_difference_hum + \
                                               delta_phase_hum *\
                                               (1 - (math.exp(-1. * delta_time / self.tau_phase_hum)))

    def get_tupple_of_current_traces(self):
        """
        Returns list of tuples containing trace and measured parameter pairs

        :return: list of tuples
        """
        return self.simulated_traces

    def create_new_trace(self, name, parameter):
        self.simulated_traces.append(name)

    def set_trace_measurements(self, trace, measurement):
        pass

    def get_current_power(self):
        return self.simulated_power

    def set_power(self, power):
        self.simulated_power = power

    def get_current_cw_frequency(self):
        return self.simulated_frequency

    def set_cw_frequency(self, frequency):
        self.simulated_frequency = frequency
        response = 'frequency set'
        return response

    def set_sweep_mode(self, mode):
        return '1'

    def get_measurement_string(self, trace, result_format):
        if trace not in self.simulated_traces:
            raise Exception('trace ' + trace + ' is not known to VNA dummy!')
        self.result_format = result_format

        simulated_magnitude = self.reference_magnitude + self.simulated_magnitude_difference_temp + \
            self.simulated_magnitude_difference_hum
        simulated_phase = self.reference_phase + self.simulated_phase_difference_temp + \
            self.simulated_phase_difference_hum
        phase_radian = simulated_phase / 180. * math.pi
        real_val = simulated_magnitude * math.cos(phase_radian)
        imaginary_val = simulated_magnitude * math.sin(phase_radian)

        measurment_string = ' '
        for i in range(50):
            measurment_string += str(real_val) + ',' + str(imaginary_val) + ','
        # doing the measurement and reading out some time
        self.simulated_state.simulated_time += self.communication_delay
        # removed last comma by adding slicing([:-1])
        return measurment_string[:-1]

    def get_list_of_measurement_values(self, trace, result_format):
        # get measurement string converted in list
        measurements = self.get_measurement_string(trace, result_format)
        result = []
        for x in measurements.split(',')[10:]:
            if x != '0' and x != '-999':  # no value is indicated with 0 for SDAT and -999 for FDAT
                result.append(float(x))
        return result

    def load_config(self, config_file, frequency):
        pass

    def do_single_sweep(self):
        pass