libacoustic_touch.h

Go to the documentation of this file.

#ifndef INCLUDED_ACOUSTIC_TOUCH_LIBACOUSTICTOUCH_H
#define INCLUDED_ACOUSTIC_TOUCH_LIBACOUSTICTOUCH_H

// C libraries
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>

// C++ libraries
#include <sstream>
#include <string>
#include <cstring>
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <map>
#include <iterator> 
#include <thread> 
#include <mutex>
#include <chrono>

// Boost libraries
#include <boost/enable_shared_from_this.hpp>
#include <boost/algorithm/string.hpp>

// ALSA includes
#include <alsa/asoundlib.h>
#include <alsa/mixer.h>

// ROS libraries
#include "ros/rate.h"
#include "ros/ros.h" 
#include "ros/console.h"
#include "ros/package.h"

// ROS parameters
#include "ros/subscriber.h"
#include "xmlrpcpp/XmlRpcValue.h"

//ROS msgs
#include "std_msgs/Empty.h"
#include "std_msgs/Float64.h"
#include "std_msgs/Int8.h"
#include "std_msgs/String.h"
#include "common_msgs/KeyValuePair.h"
#include "common_msgs/KeyValuePairArray.h"
#include "arduino_msgs/sensorStates.h"
#include "touch_gesture_msgs/SoundGesture.h"

//ROS services
#include "acoustic_touch_recognition/MenuOptions.h"

// linuxaudio library
#include "linuxaudio/utils.h"

// pstreams library
#include "pstreams/pstream.h"

// OSC-related includes and defines
#include "oscpack/ip/UdpSocket.h"
#include "oscpack/osc/OscOutboundPacketStream.h"
#include "oscpack/osc/OscReceivedElements.h"
#include "oscpack/osc/OscPacketListener.h"

#define HOST "127.0.0.1" // localhost
#define PORT 1230
#define IN_PORT 7000
#define OUTPUT_BUFFER_SIZE 1024

//colors to use in the outputs
#define RESET_COLOR "\e[m"
#define MAKE_ITALIC "\e[3m"
#define MAKE_WHITE "\e[1;97m"
#define MAKE_GREEN "\e[1;32m"
#define MAKE_BLACK "\e[0;30m"
#define MAKE_RED "\e[1;31m"
#define MAKE_BLUE "\e[1;34m"
#define MAKE_CYAN "\e[1;36m"
#define MAKE_BROWN "\e[0;33m"
#define MAKE_PURPLE "\e[1;35m"
#define MAKE_YELLOW "\e[1;33m"
#define MAKE_BLUE_UNDERLINE "\e[4;34m"
#define MAKE_YELLOW_UNDERLINE "\e[4;33m"

// ChucK macros
#define CK_DEBUG false
#define CK_LOG_PATH "/log/chuck/"
#define CK_FILE_PATH "/scripts/chuck/"
#define CK_FILE_NAME "audio_analyzer.ck"
#define CK_PULSE_LATENCY 60  // pulseaudio latency in msecs

using namespace std;
//using namespace boost::posix_time;

// ros::Duration timeSleep(1);
// volatile sig_atomic_t g_shutdown_flag;
//int numFingerPrints;

class SoundGesture
{
public:
    SoundGesture(int m_num = 0, string m_id = ""): 
    mic_num_(m_num),
    mic_id_(m_id), 
    num_attrib_(vector<double>(33,0)), 
    empty_(true), 
    waiting_(false) 
    {}

    SoundGesture(int m_num, string m_id, vector<double> atts):
    mic_num_(m_num),
    mic_id_(m_id),
    num_attrib_(atts),
    empty_(false), 
    waiting_(false) 
    {}

    ~SoundGesture()
    {}

    void setAttributes(vector<double>);
    void clearAttributes();
    void setId(string); 
    void setEmpty(bool); 
    void setWaiting(bool);

    vector<double> getAttributes()const;
    int getMicNum()const;
    string getMicId()const;
    bool isEmpty()const; 
    bool isWaiting()const; 

    SoundGesture &operator = (const SoundGesture &SG);

private:
  vector<double> num_attrib_;
    int mic_num_;
    string mic_id_; 
    bool empty_; 
    bool waiting_; 
};

class InstanceBuilder
{
public:
    // Constructor and Destructor 
    InstanceBuilder(string mode);
    ~InstanceBuilder();

    // ROS callbacks
     
    void startGestureCallback(const std_msgs::Int8::ConstPtr& msg); 
    void endGestureCallback(const touch_gesture_msgs::SoundGesture::ConstPtr& msg);
    bool optionsCallback(acoustic_touch_recognition::MenuOptions::Request  &req,
                          acoustic_touch_recognition::MenuOptions::Response &res);
    void timerCallback(const ros::TimerEvent&);
    void shutdownCallback(const ros::TimerEvent&);

    // setters
    void setSoundGestures(vector<SoundGesture> s_gests); // is useful?
    void setSoundGestures(SoundGesture s_gest, int index); // atomic, should check mic amount
    void clearSoundGestures();
    void clearSoundGestures(int index);
    void setClassAttributes(string index, string c_att); // can be more complex and check the key
    void setFile(string path);
    void closeFile();

    // getters
    vector<SoundGesture> getSoundGestures()const;
    SoundGesture getSoundGestures(int index)const;

    // methods
    void init();
    bool fileExists(string path); 
    void createArffFile(); 
    void writeGestures();

private:
    // ROS-related elements
    ros::NodeHandle nh_;
    ros::Publisher gesture_pub_; 
    ros::Subscriber gest_start_sub_; 
    bool flag_start_sub_; 
    ros::Subscriber gest_end_sub_; 
    ros::ServiceServer settings_srv_;
    ros::Timer timer_;
    ros::Timer shutdown_timer_;

    // Gesture elements 
    string robot_; 
    const string mode_;
    int mic_amount_;
    vector<SoundGesture> sound_gestures_; // one gesture per microphone // variable element 
  
    XmlRpc::XmlRpcValue class_labels_;  // map containing the whole pack of labels and its values
    XmlRpc::XmlRpcValue train_labels_;  // map containing the label name and only the selected value in the training
    vector<string> label_names_;  // for accessing quickly to map values

    // File elements
    string path_; // Fixed element again in construtor
    fstream sound_file_;
};

class ChucKHandler
{
    typedef struct ck_soundCardAttributes
    {
        uint32_t index;     // The index assigned to the soundcard. To be supplied to the ChucK command
        uint32_t number;    // Unlike the index, this number is fixed and is set in the package's configuration file
        uint32_t volume;    // the input volume, set in the configuration file
        bool capacitive;    // if there is a capacitive sensor attached to the microphone
    } ck_cardAttribs_t;

public:
    // Constructors & Destructors
    ChucKHandler(const vector<string> &);
    ChucKHandler(
        const vector<string> &, const vector<int> &, const vector<int> &, const string & = "default");
    ChucKHandler(
        const vector<string> &, const vector<int> &, const vector<int> &, const vector<bool> &, const string & = "default");
    ~ChucKHandler() {killChucK();}

    // Static Methods
    static void getShellOutput(const string &, string *, string *);
    static string fetchAlsaModel(const string &);
    static vector<string> fetchAlsaModels(const vector<string> &);
    static vector<string> fetchAlsaIDs(const string &);
    static vector<int> fetchChucKIndexes(const string &);

    // 'Getters'
    string getRobot() const;
    string getChucKMode() const;
    map<string, ck_cardAttribs_t> getSoundCards() const;
    vector<string> getSoundCardIDs() const;
    string getSoundCardID(const int &) const;
    int getSoundCardIndex(const string &) const;
    int getSoundCardNumber(const string &) const;
    int getSoundCardVolume(const string &) const;
    bool getSoundCardCapacitive(const string &) const;
    bool getKillChucK() const;

    // 'Setters'
    void setRobot(const string &);
    void setChucKMode();
    void setSoundCards(const vector<string> &);
    void setSoundCards(const vector<string> &, const vector<int> &);
    void setSoundCards(const vector<string> &, const vector<int> &, const vector<int> &);
    void setSoundCards(const vector<string> &, const vector<int> &, const vector<int> &, const vector<bool> &);
    void setSoundCardIDs(const vector<string> &);
    void setSoundCardIndex(const int &, const string &);
    void setSoundCardNumber(const int &, const string &);
    void setSoundCardVolume(const int &, const string &);
    void setSoundCardCapacitive(const bool &, const string &); 
    void setKillChucK(const bool &);

    // Main functionalities
    void printSoundCards() const;
    void setAttributesAlsa(); //TBC
    void setAttributesPulse();
    void setSoundCardInputVol(const int &, const string &);
    void chucKThread(const string &);
    void launchChucK(const bool & = CK_DEBUG); // "init" function
    void killChucK();

private:
    string robot_;
    string chuck_mode_;
    vector<string> sndcard_ids_;
    map<string, ck_cardAttribs_t> sound_cards_;
    vector<thread> ck_threads_;
    bool kill_chuck_;
};

class AcousticTouchInterface: public boost::enable_shared_from_this<AcousticTouchInterface>
{
public:
    AcousticTouchInterface(string, bool);
    ~AcousticTouchInterface();

    class ChucKPacketListener : public osc::OscPacketListener {
    public:
        ChucKPacketListener(AcousticTouchInterface& ati): at_iface_(ati){}
    protected:
        virtual void ProcessMessage(const osc::ReceivedMessage &m, 
                    const IpEndpointName& remoteEndpoint);
    private:
        AcousticTouchInterface& at_iface_;
    };

    void oscCallback(int);
    void capacitiveCallback(const arduino_msgs::sensorStates::ConstPtr &);
    void classifReadyCallback(const std_msgs::Empty::ConstPtr &);
    void sendOscMsg(string, int);
    void loadSettings();
    // void createSettings()
    void showMenu();
    void setTrainLabels(string);
    void sendSrv();
    void shutDown();
    vector<std::string> getShellOutput(const std::string);

private:
    // ROS-related elements
    ros::NodeHandle nh_;
    ros::AsyncSpinner aspin_;
    ros::Rate loop_rate_;
    ros::Subscriber capacitive_sub_;
    ros::Subscriber classif_ready_sub_;
    ros::Publisher gesture_end_pub_;
    ros::Publisher gesture_start_pub_;
    ros::Publisher loud_noise_pub_;
    ros::ServiceClient client_;
    acoustic_touch_recognition::MenuOptions srv_;

    // Audio service elements
    string robot_;  
    const string mode_; 
    bool with_GUI_;
    int cap_state_;  // the capacitive sensor array state
    bool classif_state_;

    int mic_amount_;
    XmlRpc::XmlRpcValue mics_;
    XmlRpc::XmlRpcValue class_labels_;
    vector<string> label_names_;  // for accessing quickly to map values
    
    ChucKHandler *chuck_handler_;
    
    //osc listening attributes
    mutex osc_mutex_;
    vector<thread> osc_threads_;
    vector<IpEndpointName> ip_endpoints_;
    vector<ChucKPacketListener> chuck_listeners_;
    vector<UdpListeningReceiveSocket*> udp_sockets_;
};

#endif /* INCLUDED_ACOUSTIC_TOUCH_LIBACOUSTICTOUCH_H */