signal_generator.cpp

Go to the documentation of this file.

 
#include "interfaces/teensy/signal_generator.h"

 
platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::FrontPlaneSignalGeneratorHAL_Common()
: digital_analog_converter(bus::address_from_tuple(bus::FRONTPLANE_BADDR, DAC_IDX), 7),
  function_generator(bus::address_from_tuple(bus::FRONTPLANE_BADDR, FUNCTION_GENERATOR_IDX), 7) {}
 
UnitResult platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::init()
{
  if (!digital_analog_converter.init())
    return UnitResult::err("Errr front-plane digital analog converter init failed");
  if (!function_generator.init())
    return UnitResult::err("Errr front-plane digital functin generator failed");
  return UnitResult::ok();
}
 
UnitResult platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::set_parameter(WaveForm form, uint8_t index, Parameter param, float value)
{
  if(form == WaveForm::SINE)
  {
    if(index > 0) return UnitResult::err("Invalid sine index");
    return set_sine_param(param, value);
  }
  else if(form == WaveForm::SQUARE)
  {
    if(index > 0) return UnitResult::err("Invalid square index");
    return set_square_param(param, value);
  }
  else if(form == WaveForm::CONSTANT)
  {
    if(index > 1) return UnitResult::err("Invalid constant index");
    return set_const_param(param, index, value);
  }
  return UnitResult::err("Unknown form");
}
 
float platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::get_parameter(WaveForm form, Parameter param)
{
  if(param == Parameter::FREQUENCY)
    return function_generator.get_real_frequency();
 
  if(param == Parameter::PHASE)
    return function_generator.get_real_phase();
 
  return 0.0f;
}
 
bool platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::toggle(bool enable, WaveForm form)
{
  if(enable) {
    function_generator.awake(); 
  }
  else {
    function_generator.sleep();
  }
 
  function_generator.write_wave_form(form);
 
  return true;
}
 
UnitResult platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::set_square_param(Parameter param, float value)
{
  if(param == Parameter::UPPER_BOUND)
    return write_pin(PINS::DAC_SQUARE_HIGH_CH, value * 2.0f, true);
 
  if(param == Parameter::LOWER_BOUND)
    return write_pin(PINS::DAC_SQUARE_LOW_CH, value * 2.0f, true);
 
  if(param == Parameter::FREQUENCY)
  {
    function_generator.write_frequency(value);
    return UnitResult::ok();
  }
    
  if(param == Parameter::PHASE)
  {
    function_generator.write_phase(value);
    return UnitResult::ok();
  }
 
  return UnitResult::err("Error front-plane: unknown param");
}
 
UnitResult platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::set_const_param(Parameter param, uint8_t index, float value)
{
  if(param == Parameter::VALUE && index == 0)
    return write_pin(PINS::DAC_OUT0_CH, value * 2.0f, true);
 
  if(param == Parameter::VALUE && index == 1)
    return write_pin(PINS::DAC_OUT1_CH, value * 2.0f, true);
 
  return UnitResult::ok();
}
 
UnitResult platform::interfaces::FrontPlaneSignalGeneratorHAL_Common::write_pin(PINS pin, float value, bool with_levelshift)
{
  const float hw_value = with_levelshift ? _map_dac_levelshift(value) : value;
 
  if(!digital_analog_converter.set_channel(get_pin(pin), hw_value))
    return UnitResult::err(pin_status_msg[pin]);
 
  return UnitResult::ok();
}

 
platform::interfaces::FrontPlaneSignalGenerator::FrontPlaneSignalGenerator(platform::interfaces::SignalGeneratorHAL * hardware)
: SignalGenerator(hardware) {}
 
UnitResult platform::interfaces::FrontPlaneSignalGenerator::init() {
  installed = hardware->init();
  if (installed)
    return UnitResult::ok();
  return UnitResult::err("Error front-panel failed.");
}
 
void platform::interfaces::FrontPlaneSignalGenerator::set_frequency(float frequency) { _frequency = frequency; }
 
void platform::interfaces::FrontPlaneSignalGenerator::set_phase(float phase) { _phase = phase; }
 
void platform::interfaces::FrontPlaneSignalGenerator::set_wave_form(WaveForm wave_form) { _wave_form = wave_form; }
 
bool platform::interfaces::FrontPlaneSignalGenerator::set_amplitude(float amplitude) {
  if (amplitude < 0.0f || amplitude > 1.0f)
    return false;
  _amplitude = amplitude;
  return true;
}
 
bool platform::interfaces::FrontPlaneSignalGenerator::set_square_voltage_levels(float low, float high) {
  return set_square_voltage_low(low) && set_square_voltage_high(high);
}
 
bool platform::interfaces::FrontPlaneSignalGenerator::set_square_voltage_low(float low) {
  if (fabs(low) > 1.0f)
    return false;
  _square_low_voltage = low;
  return true;
}
 
bool platform::interfaces::FrontPlaneSignalGenerator::set_square_voltage_high(float high) {
  if (fabs(high) > 1.0f)
    return false;
  _square_high_voltage = high;
  return true;
}
 
bool platform::interfaces::FrontPlaneSignalGenerator::set_offset(float offset) {
  if (fabs(offset) > 1.0f)
    return false;
  _offset = offset;
  return true;
}
 
float platform::interfaces::FrontPlaneSignalGenerator::get_real_frequency() const {
  return hardware->get_parameter(WaveForm::SINE_AND_SQUARE, Parameter::FREQUENCY);
}
 
float platform::interfaces::FrontPlaneSignalGenerator::get_real_phase() const {
  return hardware->get_parameter(WaveForm::SINE_AND_SQUARE, Parameter::PHASE);
}
 
float platform::interfaces::FrontPlaneSignalGenerator::get_frequency() const { return _frequency; }
 
float platform::interfaces::FrontPlaneSignalGenerator::get_phase() const { return _phase; }
 
WaveForm platform::interfaces::FrontPlaneSignalGenerator::get_wave_form() const { return _wave_form; }
 
float platform::interfaces::FrontPlaneSignalGenerator::get_amplitude() const { return _amplitude; }
 
float platform::interfaces::FrontPlaneSignalGenerator::get_square_voltage_low() const { return _square_low_voltage; }
 
float platform::interfaces::FrontPlaneSignalGenerator::get_square_voltage_high() const {
  return _square_high_voltage;
}
 
float platform::interfaces::FrontPlaneSignalGenerator::get_offset() const { return _offset; }
 
bool platform::interfaces::FrontPlaneSignalGenerator::get_sleep() const { return _sleep; }
 
float platform::interfaces::FrontPlaneSignalGenerator::get_dac_out0() const { return _dac_out0; }
 
float platform::interfaces::FrontPlaneSignalGenerator::get_dac_out1() const { return _dac_out1; }
 
void platform::interfaces::FrontPlaneSignalGenerator::sleep() { _sleep = true; }
 
void platform::interfaces::FrontPlaneSignalGenerator::awake() { _sleep = false; }
 
bool platform::interfaces::FrontPlaneSignalGenerator::set_dac_out0(float value) {
  if (fabs(value) > 1.0f)
    return false;
  _dac_out0 = value;
  return true;
}
 
bool platform::interfaces::FrontPlaneSignalGenerator::set_dac_out1(float value) {
  if (fabs(value) > 1.0f)
    return false;
  _dac_out1 = value;
  return true;
}
 
UnitResult platform::interfaces::FrontPlaneSignalGenerator::write_to_hardware() {
  // LUCIDAC only supports enabling _all_ function generators at once, so it's pretty much
  // irrelevant what signal we set here
  hardware->toggle(!_sleep, _wave_form);
 
  // set function generator parameters
  TRY(hardware->set_parameter(WaveForm::SINE, 0, Parameter::FREQUENCY, _frequency));
  TRY(hardware->set_parameter(WaveForm::SINE, 0, Parameter::PHASE, _phase));
  // set DAC parameters
  TRY(hardware->set_parameter(WaveForm::SINE, 0, Parameter::AMPLITUDE, _amplitude));
  TRY(hardware->set_parameter(WaveForm::SINE, 0, Parameter::OFFSET, _offset));
  TRY(hardware->set_parameter(WaveForm::SQUARE, 0, Parameter::UPPER_BOUND, _square_high_voltage));
  TRY(hardware->set_parameter(WaveForm::SQUARE, 0, Parameter::LOWER_BOUND, _square_low_voltage));
  TRY(hardware->set_parameter(WaveForm::CONSTANT, 0, Parameter::VALUE, _dac_out0));
  TRY(hardware->set_parameter(WaveForm::CONSTANT, 1, Parameter::VALUE, _dac_out1));
 
  delay(50);
  return UnitResult::ok();
}