signal_generator.cpp

Go to the documentation of this file.

 
#include "teensy/signal_generator.h"
 
FLASHMEM platform::TeensySignalGenerator::TeensySignalGenerator()
    : digital_analog_converter(bus::address_from_tuple(2, DAC_IDX)),
      function_generator(bus::address_from_tuple(2, FUNCTION_GENERATOR_IDX)) {}
 
FLASHMEM bool platform::TeensySignalGenerator::init() {
  installed = digital_analog_converter.init() && function_generator.init();
  return installed;
}
 
FLASHMEM void platform::TeensySignalGenerator::set_frequency(float frequency) { _frequency = frequency; }
 
FLASHMEM void platform::TeensySignalGenerator::set_phase(float phase) { _phase = phase; }
 
FLASHMEM void platform::TeensySignalGenerator::set_wave_form(WaveForm wave_form) { _wave_form = wave_form; }
 
FLASHMEM bool platform::TeensySignalGenerator::set_amplitude(float amplitude) {
  if (amplitude < 0.0f || amplitude > 1.0f)
    return false;
  _amplitude = amplitude;
  return true;
}
 
FLASHMEM bool platform::TeensySignalGenerator::set_square_voltage_levels(float low, float high) {
  return set_square_voltage_low(low) && set_square_voltage_high(high);
}
 
FLASHMEM bool platform::TeensySignalGenerator::set_square_voltage_low(float low) {
  if (fabs(low) > 1.0f)
    return false;
  _square_low_voltage = low;
  return true;
}
 
FLASHMEM bool platform::TeensySignalGenerator::set_square_voltage_high(float high) {
  if (fabs(high) > 1.0f)
    return false;
  _square_high_voltage = high;
  return true;
}
 
FLASHMEM bool platform::TeensySignalGenerator::set_offset(float offset) {
  if (fabs(offset) > 1.0f)
    return false;
  _offset = offset;
  return true;
}
 
FLASHMEM float platform::TeensySignalGenerator::get_real_frequency() const {
  return function_generator.get_real_frequency();
}
 
FLASHMEM float platform::TeensySignalGenerator::get_real_phase() const {
  return function_generator.get_real_phase();
}
 
FLASHMEM float platform::TeensySignalGenerator::get_frequency() const { return _frequency; }
 
FLASHMEM float platform::TeensySignalGenerator::get_phase() const { return _phase; }
 
FLASHMEM WaveForm platform::TeensySignalGenerator::get_wave_form() const { return _wave_form; }
 
FLASHMEM float platform::TeensySignalGenerator::get_amplitude() const { return _amplitude; }
 
FLASHMEM float platform::TeensySignalGenerator::get_square_voltage_low() const { return _square_low_voltage; }
 
FLASHMEM float platform::TeensySignalGenerator::get_square_voltage_high() const {
  return _square_high_voltage;
}
 
FLASHMEM float platform::TeensySignalGenerator::get_offset() const { return _offset; }
 
FLASHMEM bool platform::TeensySignalGenerator::get_sleep() const { return _sleep; }
 
FLASHMEM float platform::TeensySignalGenerator::get_dac_out0() const { return _dac_out0; }
 
FLASHMEM float platform::TeensySignalGenerator::get_dac_out1() const { return _dac_out1; }
 
FLASHMEM void platform::TeensySignalGenerator::sleep() { _sleep = true; }
 
FLASHMEM void platform::TeensySignalGenerator::awake() { _sleep = false; }
 
FLASHMEM bool platform::TeensySignalGenerator::set_dac_out0(float value) {
  if (fabs(value) > 1.0f)
    return false;
  _dac_out0 = value;
  return true;
}
 
FLASHMEM bool platform::TeensySignalGenerator::set_dac_out1(float value) {
  if (fabs(value) > 1.0f)
    return false;
  _dac_out1 = value;
  return true;
}
 
// TODO: Implement smart write to hardware for signal generator
FLASHMEM utils::status platform::TeensySignalGenerator::write_to_hardware() {
  if (_sleep)
    function_generator.sleep();
  else
    function_generator.awake();
 
  function_generator.write_frequency(_frequency);
  function_generator.write_phase(_phase);
  function_generator.write_wave_form(_wave_form);
 
  if (!digital_analog_converter.set_channel(DAC_AMPLITUDE_CH, (1.0f - _amplitude) * 2.5f))
    return utils::status(-1, "FP DAC");
  if (!digital_analog_converter.set_channel(DAC_SQUARE_LOW_CH,
                                            _map_dac_levelshift(_square_low_voltage * 2.0f)))
    return utils::status(-2, "FP DSLC");
  if (!digital_analog_converter.set_channel(DAC_SQUARE_HIGH_CH,
                                            _map_dac_levelshift(_square_high_voltage * 2.0f)))
    return utils::status(-3, "FP DSHC");
  if (!digital_analog_converter.set_channel(DAC_OFFSET_CH, _map_dac_levelshift(_offset * 2.0f)))
    return utils::status(-4, "FP DOC");
  if (!digital_analog_converter.set_channel(DAC_OUT0_CH, _map_dac_levelshift(_dac_out0 * 2.0f)))
    return utils::status(-5, "FP DO0C");
  if (!digital_analog_converter.set_channel(DAC_OUT1_CH, _map_dac_levelshift(_dac_out1 * 2.0f)))
    return utils::status(-6, "FP DO1C");
 
  delay(50);
  return utils::status::success();
}