/home/breidi/Dropbox/signalserver/include/hardware/usbamp_raw_buffer.h

/*
    This file is part of the TOBI signal server.

    The TOBI signal server is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    The TOBI signal server is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Foobar.  If not, see <http://www.gnu.org/licenses/>.

    Copyright 2010 Christian Breitwieser
    Contact: c.breitwieser@tugraz.at
*/

#ifdef WIN32

#ifndef USBAMP_H
#define USBAMP_H

#include <boost/cstdint.hpp>

#include <vector>
#include <set>

#include <boost/thread/condition.hpp>  // for mutex and cond. variables
#include <boost/thread/shared_mutex.hpp>
#include <windows.h>

#include "extern/include/g.usbamp/gUSBamp.h"
//#pragma comment(lib,"gUSBamp.lib")

#include "hw_thread.h"

namespace tobiss
{

static const unsigned int USBAMP_MAX_NR_OF_DEVICES    = 16;
static const unsigned int USBAMP_MAX_NR_OF_CHANNELS   = 17;
static const unsigned int USBAMP_MAX_NR_OF_ANALOG_CHANNELS   = 16;
static const unsigned int USBAMP_NR_OF_CHANNEL_GROUPS = 4;
static const unsigned int USBAMP_NOTCH_HALF_WIDTH = 2;   // to one side  ...  e.g.  f_center = 50 Hz -->  48/52 Hz
static const unsigned int USBAMP_ERROR_MSG_SIZE = 256;
static const unsigned int DIGITS_TO_ROUND = 2;
static const unsigned int USBAMP_SAMPLE_BUFFER_MULTIPLIER = 8;

//-----------------------------------------------------------------------------

class USBamp : public HWThread
{
  public:
//   USBamp(boost::asio::io_service& io, const HWConfig& config)
//   : HWThread(config.sampling_rate, config.nr_channels, config.blocks)
//   {
//     ch = new UCHAR [USBAMP_MAX_NR_OF_CHANNELS * sizeof(UCHAR)];
//     initUSBamp();
//   }

  USBamp(XMLParser& parser, ticpp::Iterator<ticpp::Element> hw);

  virtual ~USBamp();

  virtual SampleBlock<double> getSyncData();

  virtual SampleBlock<double> getAsyncData();

  virtual void run();

  virtual void stop();

//-----------------------------------------------

  private:

    void setHardware(ticpp::Iterator<ticpp::Element>const &hw);

    virtual void setDeviceSettings(ticpp::Iterator<ticpp::Element>const &father);
    virtual void setChannelSettings(ticpp::Iterator<ticpp::Element>const &father);

    void setDefaultSettings();
    void setDeviceFilterSettings(ticpp::Iterator<ticpp::Element>const &elem);
    void setChannelFilterSettings(ticpp::Iterator<ticpp::Element>const &father);

    void setDeviceNotchSettings(ticpp::Iterator<ticpp::Element>const &elem);
    void setChannelNotchSettings(ticpp::Iterator<ticpp::Element>const &father);

    void setOperationMode(ticpp::Iterator<ticpp::Element>const &elem);
    void setShortCut(ticpp::Iterator<ticpp::Element>const &elem);
    void setTriggerLine(ticpp::Iterator<ticpp::Element>const &elem);
    void setUSBampMasterOrSlave(ticpp::Iterator<ticpp::Element>const &elem);
    void setCommonGround(ticpp::Iterator<ticpp::Element>const &father);
    void setCommonReference(ticpp::Iterator<ticpp::Element>const &father);
    void setBipolar(ticpp::Iterator<ticpp::Element>const &father);
    void setDrivenRightLeg(ticpp::Iterator<ticpp::Element>const &father);
    void setIndividualDrivenRightLeg(ticpp::Iterator<ticpp::Element> &elem);

    void checkFilterAttributes(ticpp::Iterator<ticpp::Element>const &elem);
    void getFilterParams(ticpp::Iterator<ticpp::Element>const &elem,\
      unsigned int &type, unsigned int &order, float &f_low, float &f_high);
    void checkNotchAttributes(ticpp::Iterator<ticpp::Element>const &elem);
    void getNotchParams(ticpp::Iterator<ticpp::Element>const &elem, float &f_center);

    void checkNrOfChannels();
    void checkTriggerLineChannel();

    void getHandles();
    void check4USBampError();
    void initFilterPtrs();
    void setUSBampChannels();
    int search4FilterID(unsigned int type, unsigned int order, float f_low, float f_high);
    int search4NotchID(float f_center);
    void setUSBampFilter();
    void setUSBampNotch();

    void initUSBamp();

    void callGT_GetData();
    void fillSyncBuffer();
    void fillSampleBlock();

    inline double roundD(double number, int digits = DIGITS_TO_ROUND)
    {
      return floor(number * pow(10., digits) + .5) / pow(10., digits);
    }

  //-----------------------------------------------

  private:
    static std::set<static std::string> serials_;
    static bool is_usbamp_master_;

    static USBamp*         master_device_;
    static std::vector<USBamp*>   slave_devices_;

    bool enable_sc_;
    bool external_sync_;
    bool trigger_line_;
    boost::uint64_t sample_count_;

    boost::uint64_t error_count_;
    WORD error_code_;
    CHAR* error_msg_;

    BYTE* driver_buffer_;
    DWORD driver_buffer_size_;
    DWORD bytes_received_;
    DWORD timeout_;

    std::vector<BYTE> raw_buffer_;
    boost::uint32_t expected_values_;
    static bool received_enough_data_;

    HANDLE  h_;
    HANDLE  data_Ev_;
    OVERLAPPED ov_;

    std::vector<double> samples_;
    std::vector<boost::uint16_t> channels_;


    int nr_of_bp_filters_;
    FILT* bp_filters_;

    int nr_of_notch_filters_;
    FILT* notch_filters_;

    std::vector<boost::int16_t> filter_id_;
    std::vector<boost::int16_t> notch_id_;
    GND ground_;
    REF reference_;
    CHANNEL bipolar_channels_;
    CHANNEL drl_channels_;
    std::string mode_;

    Constants cst_;
};

} // Namespace tobiss

#endif // USBAMP_H

#endif // WIN32
//-----------------------------------------------------------------------------