signal_generator.h

Go to the documentation of this file.

#pragma once
 
#include <bus/bus.h>
#include <entity/entity.h>
#include <interfaces/signal_generator.h>
 
#include <chips/AD9834.h>
#include <chips/DAC60508.h>
#include <chips/SR74HCT595.h>
 
namespace platform {
namespace interfaces {
 
 
// ██   ██  █████  ██
// ██   ██ ██   ██ ██
// ███████ ███████ ██
// ██   ██ ██   ██ ██
// ██   ██ ██   ██ ███████
 
 
class FrontPlaneSignalGeneratorHAL_Common : public SignalGeneratorHAL
{
public:
  FrontPlaneSignalGeneratorHAL_Common();
 
  virtual bool init();
  virtual bool set_parameter(WaveForm form, uint8_t index, Parameter param, float value);
  virtual float get_parameter(WaveForm form, Parameter param);
 
  // note: it is not guaranteed that one can toggle each wave form independently;
  // if that's not the case, enable is understood as a global flag
  virtual bool toggle(bool enable, WaveForm form);
  utils::status status() { return last_status; }
 
protected:
  // used to allow different pin mappings in each instance
  enum PINS {
    DAC_AMPLITUDE_CH,
    DAC_SQUARE_HIGH_CH,
    DAC_SQUARE_LOW_CH,
    DAC_OFFSET_CH,
    DAC_OUT0_CH,
    DAC_OUT1_CH
  };
 
  virtual uint8_t get_pin(PINS pin_type) = 0;
 
  // convenience members
  virtual bool set_sine_param(Parameter param, float value) = 0;
  bool set_square_param(Parameter param, float value);
  bool set_const_param(Parameter param, uint8_t index, float value);
 
  utils::status write_pin(PINS pin, float value, bool with_levelshift = true);
  const char* pin_status_msg[6] = {
    "FP DAC",
    "FP DSLC",
    "FP DSHC",
    "FP DOC",
    "FP DO0C",
    "FP DO1C"
  };
 
  // implementation specific members
  static constexpr uint8_t FUNCTION_GENERATOR_IDX = 2;
  static constexpr uint8_t DAC_IDX = 3;
  
  const functions::DAC60508 digital_analog_converter;
  functions::AD9834 function_generator;
  utils::status last_status = utils::status::success();

  static constexpr float _map_dac_levelshift(float x) {
    return (x + 2.0f) * (0.0f - 2.5f) / (2.0f + 2.0f) + 2.5f;
  }
};
 
class FrontPlaneSignalgeneratorHAL_V_1_1_X : public FrontPlaneSignalGeneratorHAL_Common
{
public:
  bool set_sine_param(Parameter param, float value) override
  {
    // determined by experimentation, assume users enter only values in [0.25, 0.75]
    if(param == Parameter::AMPLITUDE)
      return (last_status = write_pin(PINS::DAC_AMPLITUDE_CH, (0.75f - value) / 0.5f, false)).is_ok();
 
    // determined by experimentation, assume users enter only values in [-0.5, 0.5]
    if(param == Parameter::OFFSET)
      return (last_status = write_pin(PINS::DAC_OFFSET_CH, (1.0f - 2.0f * value) * 1.25f, false)).is_ok();
 
    if(param == Parameter::FREQUENCY)
    {
      function_generator.write_frequency(value);
      return true;
    }
      
    if(param == Parameter::PHASE)
    {
      function_generator.write_phase(value);
      return true;
    }
 
    return false;
  }
protected:
  virtual uint8_t get_pin(PINS pin_type)
  {
    return _pins[pin_type];
  }
 
  const uint8_t _pins[6] = {
    0, 1, 2, 3, 4, 5
  };
};

class FrontPlaneSignalgeneratorHAL_V_1_2_X : public FrontPlaneSignalGeneratorHAL_Common
{
  public:
    bool set_sine_param(Parameter param, float value) override
    {
      if(param == Parameter::AMPLITUDE)
        return (last_status = write_pin(PINS::DAC_AMPLITUDE_CH, (1.0f - value) * 2.5f, false)).is_ok();
 
      if(param == Parameter::OFFSET)
        return (last_status = write_pin(PINS::DAC_OFFSET_CH, (1.0f - 2.0f * value) * 1.25f, false)).is_ok();
 
      if(param == Parameter::FREQUENCY)
      {
        function_generator.write_frequency(value);
        return true;
      }
        
      if(param == Parameter::PHASE)
      {
        function_generator.write_phase(value);
        return true;
      }
 
      return false;
    }
  protected:
    virtual uint8_t get_pin(PINS pin_type)
  {
    return _pins[pin_type];
  }
 
    const uint8_t _pins[6] = {
      5, 2, 1, 0, 3, 4
    };
};
 
// ██████   █████  ███████ ███████      ██████ ██       █████  ███████ ███████
// ██   ██ ██   ██ ██      ██          ██      ██      ██   ██ ██      ██
// ██████  ███████ ███████ █████       ██      ██      ███████ ███████ ███████
// ██   ██ ██   ██      ██ ██          ██      ██      ██   ██      ██      ██
// ██████  ██   ██ ███████ ███████      ██████ ███████ ██   ██ ███████ ███████
 
class FrontPlaneSignalGenerator : public SignalGenerator {
public:
  FrontPlaneSignalGenerator(SignalGeneratorHAL * hardware);
  bool init() override;

  bool is_installed() const override { return installed; }

  void set_frequency(float frequency) override;
  void set_phase(float phase) override;
  void set_wave_form(WaveForm wave_form) override;
  bool set_amplitude(float amplitude) override;
  bool set_square_voltage_levels(float low, float high) override;
  bool set_square_voltage_low(float low) override;
  bool set_square_voltage_high(float high) override;
  bool set_offset(float offset) override;

  float get_real_frequency() const override;
  float get_real_phase() const override;
 
  float get_frequency() const override;
  float get_phase() const override;
  WaveForm get_wave_form() const override;
  float get_amplitude() const override;
  float get_square_voltage_low() const override;
  float get_square_voltage_high() const override;
  float get_offset() const override;
  bool get_sleep() const override;
 
  float get_dac_out0() const override;
  float get_dac_out1() const override;

  void sleep() override;
  void awake() override;

  bool set_dac_out0(float value) override;
  bool set_dac_out1(float value) override;
 
  utils::status write_to_hardware() override;
 
private:
  float _frequency;
  float _phase;
  WaveForm _wave_form;
  float _amplitude;
  float _square_low_voltage;
  float _square_high_voltage;
  float _offset;
  float _dac_out0 = 0.0;
  float _dac_out1 = 0.0;
 
  bool _sleep = true;
 
  bool installed = false;
};
 
} // namespace interfaces
} // namespace platform