src/glove/devices/impl/CGIU.hpp

/*************************************************************************************
 * Copyright (c) 2009-2010, Christian Wressnegger
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * The names of its contributors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *************************************************************************************/

#ifndef __GLOVE_DEVICES_IMPL_CGIU_H_
#define __GLOVE_DEVICES_IMPL_CGIU_H_

#include "../../config.hpp"

#include <boost/function.hpp>
#include <boost/thread.hpp>
#include <boost/asio.hpp>
#include <boost/cstdint.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <boost/interprocess/sync/interprocess_semaphore.hpp>

#include <vector>
#include <iostream>
#include <string>

#include "../CyberGlove.hpp"

//#define DEBUG
//#define UNTESTED

namespace glove {
namespace devices {
namespace impl {

typedef boost::function<void(const std::vector<boost::uint8_t>&)> StreamHandler;

API void printByteVector(const std::vector<boost::uint8_t> v, std::ostream& os = std::cout);
API void printByteVector(const boost::uint8_t* const data, const std::size_t len, std::ostream& os =
    std::cout);
API void printSensorMask(unsigned int mask, std::ostream& os = std::cout);

#define BUFFER_SIZE 256

class API CGIU {

  class SerialPortBuffer {
    boost::interprocess::interprocess_semaphore mutex;

  public:
    std::vector<boost::uint8_t> data;

    SerialPortBuffer() :
      mutex(1) {
      mutex.wait();
    }

    void notify() {
      // TODO: semaphore max to 1 !??
      mutex.post();
    }

    void wait() {
      mutex.wait();
    }
  };
  friend struct SerialBuffer;

  boost::asio::io_service ioService;
  boost::asio::serial_port* serialPort;
  std::string port;
  boost::thread* ioThread;

  boost::interprocess::interprocess_semaphore mutex;
  SerialPortBuffer serialPortBuffer;
  boost::array<boost::uint8_t, BUFFER_SIZE> readBuffer;

  void startReading();
  void readComplete(const boost::system::error_code& error, std::size_t numBytesRead);

  void writeCommand(const std::string& cmd, const boost::uint8_t parameters[],
      const std::size_t numParameters);
  void skipToCommandHeader(const std::string& cmd);
  std::vector<boost::uint8_t> extractCommand(const std::string& cmd, const std::size_t cmdLength,
      const bool skipHeader = false);
  std::vector<boost::uint8_t> readCommand(const std::string& cmd, const std::size_t sizeHint,
      const boost::uint8_t delimiter, const bool skipHeader = false);

  static const unsigned int timeout;

  static const std::string INVALID_CMD;
  static const std::string SAMPLING_ERROR;
  static const std::string GLOVE_ERROR;

  bool isValidResponse(const std::string& cmd, const std::vector<boost::uint8_t>& response,
      const std::size_t minimalResponseLength = 0);
  bool isValidSensorRecord(const std::vector<boost::uint8_t>& record, std::string* validationStr =
      NULL);

  bool isStreaming_;
  boost::thread* streamThread;
  void processRecordStream(StreamHandler handler);

protected:

  std::vector<boost::uint8_t>
  command(const std::string& cmd, std::size_t minimalResponseLength = 0);
  std::vector<boost::uint8_t> command(const std::string& cmd, const boost::uint8_t parameters[],
      const std::size_t numParameters, std::size_t minimalResponseLength = 0);

  void set(const std::string& cmd, const bool b = true);
  bool getBool(const std::string& cmd);
  boost::uint8_t getByte(const std::string& cmd);
  unsigned int getBytes(const std::string& cmd, const unsigned short numBytes);
  std::string getString(const std::string& cmd);

public:
  CGIU();
  virtual ~CGIU();

  void connect(const std::string& port);
  bool isConnected() const;
  void disconnect();
  const std::string& getPort();

  void requestGloveStatus(const bool b = true);
  bool gloveStatusRequested();

  void requestQuantizedValues(const bool b = true);
  bool quantizedValuesRequested();

#ifdef UNTESTED
  void requestTimestamp(const bool b = true);
  bool timestampRequested();

  void setCalibration(); // p26
  void setSensorOffset(); // p26
  void setSensorGain(); // p26

  void setActuation(std::vector<std::pair<CyberGlove::Finger, boost::uint8_t> > amplitudes);
  void setBaudRate(); // p25
  void setSampleRate(); // p47

  void setParameters(int p); // p41
#endif

  unsigned int getParameters();

  std::vector<boost::uint8_t> getSensorValues();
  void streamSensorValues(void(*f)(const std::vector<boost::uint8_t>&));
  void streamSensorValues(StreamHandler h);
  void stopStreaming();
  bool isStreaming() const;

#ifdef UNTESTED
  unsigned int hardwareSensorMask();
#endif

  unsigned int softwareSensorMask();
  void softwareSensorMask(unsigned int mask);

  int numSensors();
  bool isRightHanded();
  bool isLeftHanded();

#ifdef UNTESTED
  void enableNoiseFilter(const bool b = true);
  bool isNoiseFilterEnabled();
#endif

  void enableSwitch(const bool b = true);
  bool isSwitchEnabled();

  void cancel();
  void restart();
  void reinitialize();

  std::string usage();
  std::string info();
  std::pair<int, int> version();

  virtual std::string toString();

};

}
}
}

#endif /* __GLOVE_DEVICES_IMPL_CGIU_H_ */

---