diff --git a/MYO4Live.amxd b/MYO4Live.amxd new file mode 100644 index 0000000..263b1dd Binary files /dev/null and b/MYO4Live.amxd differ diff --git a/MYO4Live.maxproj b/MYO4Live.maxproj index a5b654c..1400ab4 100644 --- a/MYO4Live.maxproj +++ b/MYO4Live.maxproj @@ -2,13 +2,21 @@ "name" : "MYO4Live", "version" : 1, "creationdate" : 3654856293, - "modificationdate" : 3654856293, + "modificationdate" : 3654856392, "viewrect" : [ 25.0, 70.0, 300.0, 500.0 ], "autoorganize" : 1, "hideprojectwindow" : 0, "showdependencies" : 1, "autolocalize" : 0, "contents" : { + "patchers" : { + "main.maxpat" : { + "kind" : "patcher", + "local" : 1, + "toplevel" : 1 + } + + } } , diff --git a/other/.DS_Store b/other/.DS_Store new file mode 100644 index 0000000..ea3db6e Binary files /dev/null and b/other/.DS_Store differ diff --git a/other/myo-osc b/other/myo-osc new file mode 100755 index 0000000..55060d6 Binary files /dev/null and b/other/myo-osc differ diff --git a/other/myo.framework/.DS_Store b/other/myo.framework/.DS_Store new file mode 100644 index 0000000..570264c Binary files /dev/null and b/other/myo.framework/.DS_Store differ diff --git a/other/myo.framework/Headers/cxx/DeviceListener.hpp b/other/myo.framework/Headers/cxx/DeviceListener.hpp new file mode 100755 index 0000000..816cab3 --- /dev/null +++ b/other/myo.framework/Headers/cxx/DeviceListener.hpp @@ -0,0 +1,197 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include "Pose.hpp" + +namespace myo { + +class Myo; +template +class Quaternion; +template +class Vector3; + +/// Enumeration identifying a right arm or left arm. +enum Arm { + armLeft = libmyo_arm_left, + armRight = libmyo_arm_right, + armUnknown = libmyo_arm_unknown +}; + +/// Possible directions for Myo's +x axis relative to a user's arm. +enum XDirection { + xDirectionTowardWrist = libmyo_x_direction_toward_wrist, + xDirectionTowardElbow = libmyo_x_direction_toward_elbow, + xDirectionUnknown = libmyo_x_direction_unknown +}; + +/// Possible warmup states for a Myo. +enum WarmupState { + warmupStateUnknown = libmyo_warmup_state_unknown, + warmupStateCold = libmyo_warmup_state_cold, + warmupStateWarm = libmyo_warmup_state_warm, +}; + +/// Possible warmup results for a Myo. +enum WarmupResult { + warmupResultUnknown = libmyo_warmup_result_unknown, + warmupResultSuccess = libmyo_warmup_result_success, + warmupResultFailedTimeout = libmyo_warmup_result_failed_timeout, +}; + +/// Firmware version of Myo. +struct FirmwareVersion { + unsigned int firmwareVersionMajor; ///< Myo's major version must match the required major version. + unsigned int firmwareVersionMinor; ///< Myo's minor version must match the required minor version. + unsigned int firmwareVersionPatch; ///< Myo's patch version must greater or equal to the required patch version. + unsigned int firmwareVersionHardwareRev; ///< Myo's hardware revision; not used to detect firmware version mismatch. +}; + +/// A DeviceListener receives events about a Myo. +/// @see Hub::addListener() +class DeviceListener { +public: + virtual ~DeviceListener() {} + + /// Called when a Myo has been paired. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param firmwareVersion The firmware version of \a myo. + virtual void onPair(Myo* myo, uint64_t timestamp, FirmwareVersion firmwareVersion) {} + + /// Called when a Myo has been unpaired. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onUnpair(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo has been connected. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param firmwareVersion The firmware version of \a myo. + virtual void onConnect(Myo* myo, uint64_t timestamp, FirmwareVersion firmwareVersion) {} + + /// Called when a paired Myo has been disconnected. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onDisconnect(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo recognizes that it is on an arm. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param arm The identified Arm of \a myo. + /// @param xDirection The identified XDirection of \a myo. + /// @param rotation The estimated rotation of Myo on the user's arm after a sync. + /// @param warmupState The warmup state of \a myo. If \a warmupState is equal to WarmupState::warmupStateCold, + /// onWarmupCompleted() will be called when the warmup period has completed. + virtual void onArmSync(Myo* myo, uint64_t timestamp, Arm arm, XDirection xDirection, float rotation, + WarmupState warmupState) {} + + /// Called when a paired Myo is moved or removed from the arm. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onArmUnsync(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo becomes unlocked. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onUnlock(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo becomes locked. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onLock(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo has provided a new pose. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param pose The identified Pose of \a myo. + virtual void onPose(Myo* myo, uint64_t timestamp, Pose pose) {} + + /// Called when a paired Myo has provided new orientation data. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param rotation The orientation data of \a myo, as a Quaternion. + virtual void onOrientationData(Myo* myo, uint64_t timestamp, const Quaternion& rotation) {} + + /// Called when a paired Myo has provided new accelerometer data in units of g. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param accel The accelerometer data of \a myo, in units of g. + virtual void onAccelerometerData(Myo* myo, uint64_t timestamp, const Vector3& accel) {} + + /// Called when a paired Myo has provided new gyroscope data in units of deg/s. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param gyro The gyroscope data of \a myo, in units of deg/s. + virtual void onGyroscopeData(Myo* myo, uint64_t timestamp, const Vector3& gyro) {} + + /// Called when a paired Myo has provided a new RSSI value. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param rssi The RSSI (received signal strength indication) of \a myo. + /// @see Myo::requestRssi() to request an RSSI value from the Myo. + virtual void onRssi(Myo* myo, uint64_t timestamp, int8_t rssi) {} + + /// Called when a paired Myo receives an battery level update. + /// Updates occur when the battery level changes and when the battery level is explicitly requested. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param level battery level reported by the myo the value is a number from 0 to 100 representing the percentage + /// of battery life remaining. + virtual void onBatteryLevelReceived(myo::Myo* myo, uint64_t timestamp, uint8_t level) {} + + /// Called when a paired Myo has provided new EMG data. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param emg An array of 8 elements, each corresponding to one sensor. + virtual void onEmgData(myo::Myo* myo, uint64_t timestamp, const int8_t* emg) {} + + /// Called when the warmup period for a Myo has completed. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param warmupResult The warmup result of \a myo. + virtual void onWarmupCompleted(myo::Myo* myo, uint64_t timestamp, WarmupResult warmupResult) {} + + /// @cond LIBMYO_INTERNALS + + virtual void onOpaqueEvent(libmyo_event_t event) {} + + /// @endcond +}; + +} // namespace myo diff --git a/other/myo.framework/Headers/cxx/Hub.hpp b/other/myo.framework/Headers/cxx/Hub.hpp new file mode 100755 index 0000000..1d4a3e0 --- /dev/null +++ b/other/myo.framework/Headers/cxx/Hub.hpp @@ -0,0 +1,91 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include + +namespace myo { + +class Myo; +class DeviceListener; + +/// @brief A Hub provides access to one or more Myo instances. +class Hub { +public: + /// Construct a hub. + /// \a applicationIdentifier must follow a reverse domain name format (ex. com.domainname.appname). Application + /// identifiers can be formed from the set of alphanumeric ASCII characters (a-z, A-Z, 0-9). The hyphen (-) and + /// underscore (_) characters are permitted if they are not adjacent to a period (.) character (i.e. not at the + /// start or end of each segment), but are not permitted in the top-level domain. Application identifiers must have + /// three or more segments. For example, if a company's domain is example.com and the application is named + /// hello-world, one could use "com.example.hello-world" as a valid application identifier. \a applicationIdentifier + /// can be an empty string. + /// Throws an exception of type std::invalid_argument if \a applicationIdentifier is not in the proper reverse + /// domain name format or is longer than 255 characters. + /// Throws an exception of type std::runtime_error if the hub initialization failed for some reason, typically + /// because Myo Connect is not running and a connection can thus not be established. + Hub(const std::string& applicationIdentifier = ""); + + /// Deallocate any resources associated with a Hub. + /// This will cause all Myo instances retrieved from this Hub to become invalid. + ~Hub(); + + /// Wait for a Myo to become paired, or time out after \a timeout_ms milliseconds if provided. + /// If \a timeout_ms is zero, this function blocks until a Myo is found. + /// This function must not be called concurrently with run() or runOnce(). + Myo* waitForMyo(unsigned int milliseconds = 0); + + /// Register a listener to be called when device events occur. + void addListener(DeviceListener* listener); + + /// Remove a previously registered listener. + void removeListener(DeviceListener* listener); + + /// Locking policies supported by Myo. + enum LockingPolicy { + lockingPolicyNone = libmyo_locking_policy_none, + lockingPolicyStandard = libmyo_locking_policy_standard + }; + + /// Set the locking policy for Myos connected to the Hub. + void setLockingPolicy(LockingPolicy lockingPolicy); + + /// Run the event loop for the specified duration (in milliseconds). + void run(unsigned int duration_ms); + + /// Run the event loop until a single event occurs, or the specified duration (in milliseconds) has elapsed. + void runOnce(unsigned int duration_ms); + + /// @cond MYO_INTERNALS + + /// Return the internal libmyo object corresponding to this hub. + libmyo_hub_t libmyoObject(); + +protected: + void onDeviceEvent(libmyo_event_t event); + + Myo* lookupMyo(libmyo_myo_t opaqueMyo) const; + + Myo* addMyo(libmyo_myo_t opaqueMyo); + + libmyo_hub_t _hub; + std::vector _myos; + std::vector _listeners; + + /// @endcond + +private: + // Not implemented + Hub(const Hub&); + Hub& operator=(const Hub&); +}; + +/// @example hello-myo.cpp +/// @example multiple-myos.cpp +/// @example emg-data-sample.cpp + +} // namespace myo + +#include "impl/Hub_impl.hpp" diff --git a/other/myo.framework/Headers/cxx/Myo.hpp b/other/myo.framework/Headers/cxx/Myo.hpp new file mode 100755 index 0000000..c030e09 --- /dev/null +++ b/other/myo.framework/Headers/cxx/Myo.hpp @@ -0,0 +1,83 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +namespace myo { + +/// Represents a Myo device with a specific MAC address. +/// This class can not be instantiated directly; instead, use Hub to get access to a Myo. +/// There is only one Myo instance corresponding to each device; thus, if the addresses of two Myo instances compare +/// equal, they refer to the same device. +class Myo { +public: + /// Types of vibration supported by the Myo. + enum VibrationType { + vibrationShort = libmyo_vibration_short, + vibrationMedium = libmyo_vibration_medium, + vibrationLong = libmyo_vibration_long + }; + + /// Vibrate the Myo. + void vibrate(VibrationType type); + + /// Request the RSSI of the Myo. An onRssi event will likely be generated with the value of the RSSI. + /// @see DeviceListener::onRssi() + void requestRssi() const; + + /// Request the battery level of the Myo. An onBatteryLevelReceived event will be generated with the value. + /// @see DeviceListener::onBatteryLevelReceived(). + void requestBatteryLevel() const; + + /// Unlock types supported by Myo. + enum UnlockType { + unlockTimed = libmyo_unlock_timed, + unlockHold = libmyo_unlock_hold + }; + + /// Unlock the Myo. + /// Myo will remain unlocked for a short amount of time, after which it will automatically lock again. + /// If Myo was locked, an onUnlock event will be generated. + void unlock(UnlockType type); + + /// Force the Myo to lock immediately. + /// If Myo was unlocked, an onLock event will be generated. + void lock(); + + /// Notify the Myo that a user action was recognized. + /// Will cause Myo to vibrate. + void notifyUserAction(); + + /// Valid EMG streaming modes for a Myo. + enum StreamEmgType { + streamEmgDisabled = libmyo_stream_emg_disabled, + streamEmgEnabled = libmyo_stream_emg_enabled + }; + + /// Sets the EMG streaming mode for a Myo. + void setStreamEmg(StreamEmgType type); + + /// @cond MYO_INTERNALS + + /// Return the internal libmyo object corresponding to this device. + libmyo_myo_t libmyoObject() const; + + /// @endcond + +private: + Myo(libmyo_myo_t myo); + ~Myo(); + + libmyo_myo_t _myo; + + // Not implemented. + Myo(const Myo&); + Myo& operator=(const Myo&); + + friend class Hub; +}; + +} // namespace myo + +#include "impl/Myo_impl.hpp" diff --git a/other/myo.framework/Headers/cxx/Pose.hpp b/other/myo.framework/Headers/cxx/Pose.hpp new file mode 100755 index 0000000..8d668b4 --- /dev/null +++ b/other/myo.framework/Headers/cxx/Pose.hpp @@ -0,0 +1,70 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include +#include + +#include + +namespace myo { + +/// A pose represents a detected configuration of the user's hand. +class Pose { +public: + /// Types of poses supported by the SDK. + enum Type { + rest = libmyo_pose_rest, + fist = libmyo_pose_fist, + waveIn = libmyo_pose_wave_in, + waveOut = libmyo_pose_wave_out, + fingersSpread = libmyo_pose_fingers_spread, + doubleTap = libmyo_pose_double_tap, + unknown = libmyo_pose_unknown + }; + + /// Construct a pose of type Pose::none. + Pose(); + + /// Construct a pose with the given type. + Pose(Type type); + + /// Returns true if and only if the two poses are of the same type. + bool operator==(Pose other) const; + + /// Equivalent to `!(*this == other)`. + bool operator!=(Pose other) const; + + /// Returns the type of this pose. + Type type() const; + + /// Return a human-readable string representation of the pose. + std::string toString() const; + +private: + Type _type; +}; + +/// @relates Pose +/// Returns true if and only if the type of pose is the same as the provided type. +bool operator==(Pose pose, Pose::Type t); + +/// @relates Pose +/// Equivalent to `pose == type`. +bool operator==(Pose::Type type, Pose pose); + +/// @relates Pose +/// Equivalent to `!(pose == type)`. +bool operator!=(Pose pose, Pose::Type type); + +/// @relates Pose +/// Equivalent to `!(type == pose)`. +bool operator!=(Pose::Type type, Pose pose); + +/// @relates Pose +/// Write the name of the provided pose to the provided output stream. +std::ostream& operator<<(std::ostream& out, const Pose& pose); + +} // namespace myo + +#include "impl/Pose_impl.hpp" diff --git a/other/myo.framework/Headers/cxx/Quaternion.hpp b/other/myo.framework/Headers/cxx/Quaternion.hpp new file mode 100755 index 0000000..6e56df3 --- /dev/null +++ b/other/myo.framework/Headers/cxx/Quaternion.hpp @@ -0,0 +1,158 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include "Vector3.hpp" + +namespace myo { + +/// A quaternion that can be used to represent a rotation. +/// This type provides only very basic functionality to store quaternions that's sufficient to retrieve the data to +/// be placed in a full featured quaternion type. +template +class Quaternion { + public: + /// Construct a quaternion that represents zero rotation (i.e. the multiplicative identity). + Quaternion() + : _x(0) + , _y(0) + , _z(0) + , _w(1) + { + } + + /// Construct a quaternion with the provided components. + Quaternion(T x, T y, T z, T w) + : _x(x) + , _y(y) + , _z(z) + , _w(w) + { + } + + /// Set the components of this quaternion to be those of the other. + Quaternion& operator=(const Quaternion other) + { + _x = other._x; + _y = other._y; + _z = other._z; + _w = other._w; + + return *this; + } + + /// Return the x-component of this quaternion's vector. + T x() const { return _x; } + + /// Return the y-component of this quaternion's vector. + T y() const { return _y; } + + /// Return the z-component of this quaternion's vector. + T z() const { return _z; } + + /// Return the w-component (scalar) of this quaternion. + T w() const { return _w; } + + /// Return the quaternion multiplied by \a rhs. + /// Note that quaternion multiplication is not commutative. + Quaternion operator*(const Quaternion& rhs) const + { + return Quaternion( + _w * rhs._x + _x * rhs._w + _y * rhs._z - _z * rhs._y, + _w * rhs._y - _x * rhs._z + _y * rhs._w + _z * rhs._x, + _w * rhs._z + _x * rhs._y - _y * rhs._x + _z * rhs._w, + _w * rhs._w - _x * rhs._x - _y * rhs._y - _z * rhs._z + ); + } + + /// Multiply this quaternion by \a rhs. + /// Return this quaternion updated with the result. + Quaternion& operator*=(const Quaternion& rhs) + { + *this = *this * rhs; + return *this; + } + + /// Return the unit quaternion corresponding to the same rotation as this one. + Quaternion normalized() const + { + T magnitude = std::sqrt(_x * _x + _y * _y + _z * _z + _w * _w); + + return Quaternion(_x / magnitude, _y / magnitude, _z / magnitude, _w / magnitude); + } + + /// Return this quaternion's conjugate. + Quaternion conjugate() const + { + return Quaternion(-_x, -_y, -_z, _w); + } + + /// Return a quaternion that represents a right-handed rotation of \a angle radians about the given \a axis. + /// \a axis The unit vector representing the axis of rotation. + /// \a angle The angle of rotation, in radians. + static Quaternion fromAxisAngle(const myo::Vector3& axis, T angle) + { + return Quaternion(axis.x() * std::sin(angle / 2), + axis.y() * std::sin(angle / 2), + axis.z() * std::sin(angle / 2), + std::cos(angle / 2)); + } + + private: + T _x, _y, _z, _w; +}; + +/// Return a copy of this \a vec rotated by \a quat. +/// \relates myo::Quaternion +template +Vector3 rotate(const Quaternion& quat, const Vector3& vec) +{ + myo::Quaternion qvec(vec.x(), vec.y(), vec.z(), 0); + myo::Quaternion result = quat * qvec * quat.conjugate(); + return Vector3(result.x(), result.y(), result.z()); +} + +/// Return a quaternion that represents a rotation from vector \a from to \a to. +/// \relates myo::Quaternion +/// See http://stackoverflow.com/questions/1171849/finding-quaternion-representing-the-rotation-from-one-vector-to-another +/// for some explanation. +template +Quaternion rotate(const Vector3& from, const Vector3& to) +{ + Vector3 cross = from.cross(to); + + // The product of the square of magnitudes and the cosine of the angle between from and to. + T cosTheta = from.dot(to); + + // Return identity if the vectors are the same direction. + if (cosTheta >= 1) { + return Quaternion(); + } + + // The product of the square of the magnitudes + T k = std::sqrt(from.dot(from) * to.dot(to)); + + // Return identity in the degenerate case. + if (k <= 0) { + return Quaternion(); + } + + // Special handling for vectors facing opposite directions. + if (cosTheta / k <= -1) { + Vector3 xAxis(1, 0, 0); + Vector3 yAxis(0, 1, 0); + + cross = from.cross(std::abs(from.dot(xAxis)) < 1 ? xAxis : yAxis); + k = cosTheta = 0; + } + + return Quaternion( + cross.x(), + cross.y(), + cross.z(), + k + cosTheta); +} + +} // namespace myo diff --git a/other/myo.framework/Headers/cxx/Vector3.hpp b/other/myo.framework/Headers/cxx/Vector3.hpp new file mode 100755 index 0000000..774654b --- /dev/null +++ b/other/myo.framework/Headers/cxx/Vector3.hpp @@ -0,0 +1,103 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#define _USE_MATH_DEFINES +#include + +namespace myo { + +/// A vector of three components. +/// This type provides very basic functionality to store a three dimensional vector that's sufficient to retrieve +/// the data to be placed in a full featured vector type. A few common vector operations, such as dot product and +/// cross product, are also provided. +template +class Vector3 { + public: + /// Construct a vector of all zeroes. + Vector3() + { + _data[0] = 0; + _data[1] = 0; + _data[2] = 0; + } + + /// Construct a vector with the three provided components. + Vector3(T x, T y, T z) + { + _data[0] = x; + _data[1] = y; + _data[2] = z; + } + + /// Construct a vector with the same components as \a other. + Vector3(const Vector3& other) + { + *this = other; + } + + /// Set the components of this vector to be the same as \a other. + Vector3& operator=(const Vector3& other) + { + _data[0] = other._data[0]; + _data[1] = other._data[1]; + _data[2] = other._data[2]; + + return *this; + } + + /// Return a copy of the component of this vector at \a index, which should be 0, 1, or 2. + T operator[](unsigned int index) const + { + return _data[index]; + } + + /// Return the x-component of this vector. + T x() const { return _data[0]; } + + /// Return the y-component of this vector. + T y() const { return _data[1]; } + + /// Return the z-component of this vector. + T z() const { return _data[2]; } + + /// Return the magnitude of this vector. + T magnitude() const + { + return std::sqrt(x() * x() + y() * y() + z() * z()); + } + + /// Return a normalized copy of this vector. + Vector3 normalized() const + { + T norm = magnitude(); + return Vector3(x() / norm, y() / norm, z() / norm); + } + + /// Return the dot product of this vector and \a rhs. + T dot(const Vector3& rhs) const + { + return x() * rhs.x() + y() * rhs.y() + z() * rhs.z(); + } + + /// Return the cross product of this vector and \a rhs. + Vector3 cross(const Vector3& rhs) const + { + return Vector3( + y() * rhs.z() - z() * rhs.y(), + z() * rhs.x() - x() * rhs.z(), + x() * rhs.y() - y() * rhs.x() + ); + } + + /// Return the angle between this vector and \a rhs, in radians. + T angleTo(const Vector3& rhs) const + { + return std::acos(dot(rhs) / (magnitude() * rhs.magnitude())); + } + + private: + T _data[3]; +}; + +} // namespace myo diff --git a/other/myo.framework/Headers/cxx/detail/ThrowOnError.hpp b/other/myo.framework/Headers/cxx/detail/ThrowOnError.hpp new file mode 100755 index 0000000..3be0f3f --- /dev/null +++ b/other/myo.framework/Headers/cxx/detail/ThrowOnError.hpp @@ -0,0 +1,70 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_CXX_DETAIL_THROWONERROR_HPP +#define MYO_CXX_DETAIL_THROWONERROR_HPP + +#include + +#include + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +#define LIBMYO_NOEXCEPT(b) +#else +#if __cplusplus >= 201103L +# define LIBMYO_NOEXCEPT(b) noexcept(b) +#else +# define LIBMYO_NOEXCEPT(b) +#endif +#endif + +namespace myo { + +class ThrowOnError { +public: + ThrowOnError() + : _error() + { + } + + ~ThrowOnError() LIBMYO_NOEXCEPT(false) + { + if (_error) + { + switch (libmyo_error_kind(_error)) { + case libmyo_error: + case libmyo_error_runtime: + { + std::runtime_error exception(libmyo_error_cstring(_error)); + libmyo_free_error_details(_error); + throw exception; + } + case libmyo_error_invalid_argument: + { + std::invalid_argument exception(libmyo_error_cstring(_error)); + libmyo_free_error_details(_error); + throw exception; + } + case libmyo_success: + { + break; + } + } + } + } + + operator libmyo_error_details_t*() + { + return &_error; + } + +private: + libmyo_error_details_t _error; + + // Not implemented + ThrowOnError(const ThrowOnError&); // = delete; + ThrowOnError& operator=(const ThrowOnError&); // = delete; +}; + +} //namespace libmyo + +#endif // MYO_CXX_DETAIL_THROWONERROR_HPP diff --git a/other/myo.framework/Headers/cxx/impl/Hub_impl.hpp b/other/myo.framework/Headers/cxx/impl/Hub_impl.hpp new file mode 100755 index 0000000..5e5244e --- /dev/null +++ b/other/myo.framework/Headers/cxx/impl/Hub_impl.hpp @@ -0,0 +1,265 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#include "../Hub.hpp" + +#include +#include + +#include "../DeviceListener.hpp" +#include "../Myo.hpp" +#include "../Pose.hpp" +#include "../Quaternion.hpp" +#include "../Vector3.hpp" +#include "../detail/ThrowOnError.hpp" + +namespace myo { + +inline +Hub::Hub(const std::string& applicationIdentifier) +: _hub(0) +, _myos() +, _listeners() +{ + libmyo_init_hub(&_hub, applicationIdentifier.c_str(), ThrowOnError()); +} + +inline +Hub::~Hub() +{ + for (std::vector::iterator I = _myos.begin(), IE = _myos.end(); I != IE; ++I) { + delete *I; + } + libmyo_shutdown_hub(_hub, 0); +} + +inline +Myo* Hub::waitForMyo(unsigned int timeout_ms) +{ + std::size_t prevSize = _myos.size(); + + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + libmyo_myo_t opaque_myo = libmyo_event_get_myo(event); + + switch (libmyo_event_get_type(event)) { + case libmyo_event_paired: + hub->addMyo(opaque_myo); + return libmyo_handler_stop; + default: + break; + } + + return libmyo_handler_continue; + } + }; + + do { + libmyo_run(_hub, timeout_ms ? timeout_ms : 1000, &local::handler, this, ThrowOnError()); + } while (!timeout_ms && _myos.size() <= prevSize); + + if (_myos.size() <= prevSize) { + return 0; + } + + return _myos.back(); +} + +inline +void Hub::addListener(DeviceListener* listener) +{ + if (std::find(_listeners.begin(), _listeners.end(), listener) != _listeners.end()) { + // Listener was already added. + return; + } + _listeners.push_back(listener); +} + +inline +void Hub::removeListener(DeviceListener* listener) +{ + std::vector::iterator I = std::find(_listeners.begin(), _listeners.end(), listener); + if (I == _listeners.end()) { + // Don't have this listener. + return; + } + + _listeners.erase(I); +} + +inline +void Hub::setLockingPolicy(LockingPolicy lockingPolicy) +{ + libmyo_set_locking_policy(_hub, static_cast(lockingPolicy), ThrowOnError()); +} + +inline +void Hub::onDeviceEvent(libmyo_event_t event) +{ + libmyo_myo_t opaqueMyo = libmyo_event_get_myo(event); + + Myo* myo = lookupMyo(opaqueMyo); + + if (!myo && libmyo_event_get_type(event) == libmyo_event_paired) { + myo = addMyo(opaqueMyo); + } + + if (!myo) { + // Ignore events for Myos we don't know about. + return; + } + + for (std::vector::iterator I = _listeners.begin(), IE = _listeners.end(); I != IE; ++I) { + DeviceListener* listener = *I; + + listener->onOpaqueEvent(event); + + uint64_t time = libmyo_event_get_timestamp(event); + + switch (libmyo_event_get_type(event)) { + case libmyo_event_paired: { + FirmwareVersion version = {libmyo_event_get_firmware_version(event, libmyo_version_major), + libmyo_event_get_firmware_version(event, libmyo_version_minor), + libmyo_event_get_firmware_version(event, libmyo_version_patch), + libmyo_event_get_firmware_version(event, libmyo_version_hardware_rev)}; + listener->onPair(myo, time, version); + break; + } + case libmyo_event_unpaired: + listener->onUnpair(myo, time); + break; + case libmyo_event_connected: { + FirmwareVersion version = {libmyo_event_get_firmware_version(event, libmyo_version_major), + libmyo_event_get_firmware_version(event, libmyo_version_minor), + libmyo_event_get_firmware_version(event, libmyo_version_patch), + libmyo_event_get_firmware_version(event, libmyo_version_hardware_rev)}; + listener->onConnect(myo, time, version); + break; + } + case libmyo_event_disconnected: + listener->onDisconnect(myo, time); + break; + case libmyo_event_arm_synced: + listener->onArmSync(myo, time, + static_cast(libmyo_event_get_arm(event)), + static_cast(libmyo_event_get_x_direction(event)), + libmyo_event_get_rotation_on_arm(event), + static_cast(libmyo_event_get_warmup_state(event))); + break; + case libmyo_event_arm_unsynced: + listener->onArmUnsync(myo, time); + break; + case libmyo_event_unlocked: + listener->onUnlock(myo, time); + break; + case libmyo_event_locked: + listener->onLock(myo, time); + break; + case libmyo_event_orientation: + listener->onOrientationData(myo, time, + Quaternion(libmyo_event_get_orientation(event, libmyo_orientation_x), + libmyo_event_get_orientation(event, libmyo_orientation_y), + libmyo_event_get_orientation(event, libmyo_orientation_z), + libmyo_event_get_orientation(event, libmyo_orientation_w))); + listener->onAccelerometerData(myo, time, + Vector3(libmyo_event_get_accelerometer(event, 0), + libmyo_event_get_accelerometer(event, 1), + libmyo_event_get_accelerometer(event, 2))); + + listener->onGyroscopeData(myo, time, + Vector3(libmyo_event_get_gyroscope(event, 0), + libmyo_event_get_gyroscope(event, 1), + libmyo_event_get_gyroscope(event, 2))); + + break; + case libmyo_event_pose: + listener->onPose(myo, time, Pose(static_cast(libmyo_event_get_pose(event)))); + break; + case libmyo_event_rssi: + listener->onRssi(myo, time, libmyo_event_get_rssi(event)); + break; + case libmyo_event_battery_level: + listener->onBatteryLevelReceived(myo, time, libmyo_event_get_battery_level(event)); + break; + case libmyo_event_emg: { + int8_t emg[] = { libmyo_event_get_emg(event, 0), + libmyo_event_get_emg(event, 1), + libmyo_event_get_emg(event, 2), + libmyo_event_get_emg(event, 3), + libmyo_event_get_emg(event, 4), + libmyo_event_get_emg(event, 5), + libmyo_event_get_emg(event, 6), + libmyo_event_get_emg(event, 7) }; + listener->onEmgData(myo, time, emg); + break; + } + case libmyo_event_warmup_completed: { + listener->onWarmupCompleted(myo, time, static_cast(libmyo_event_get_warmup_result(event))); + break; + } + } + } +} + +inline +void Hub::run(unsigned int duration_ms) +{ + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + hub->onDeviceEvent(event); + + return libmyo_handler_continue; + } + }; + libmyo_run(_hub, duration_ms, &local::handler, this, ThrowOnError()); +} + +inline +void Hub::runOnce(unsigned int duration_ms) +{ + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + hub->onDeviceEvent(event); + + return libmyo_handler_stop; + } + }; + libmyo_run(_hub, duration_ms, &local::handler, this, ThrowOnError()); +} + +inline +libmyo_hub_t Hub::libmyoObject() +{ + return _hub; +} + +inline +Myo* Hub::lookupMyo(libmyo_myo_t opaqueMyo) const +{ + Myo* myo = 0; + for (std::vector::const_iterator I = _myos.begin(), IE = _myos.end(); I != IE; ++I) { + if ((*I)->libmyoObject() == opaqueMyo) { + myo = *I; + break; + } + } + + return myo; +} + +inline +Myo* Hub::addMyo(libmyo_myo_t opaqueMyo) +{ + Myo* myo = new Myo(opaqueMyo); + + _myos.push_back(myo); + + return myo; +} + +} // namespace myo diff --git a/other/myo.framework/Headers/cxx/impl/Myo_impl.hpp b/other/myo.framework/Headers/cxx/impl/Myo_impl.hpp new file mode 100755 index 0000000..84d8125 --- /dev/null +++ b/other/myo.framework/Headers/cxx/impl/Myo_impl.hpp @@ -0,0 +1,72 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#include "../Myo.hpp" +#include "../detail/ThrowOnError.hpp" + +#include + +namespace myo { + +inline +void Myo::vibrate(VibrationType type) +{ + libmyo_vibrate(_myo, static_cast(type), ThrowOnError()); +} + +inline +void Myo::requestRssi() const +{ + libmyo_request_rssi(_myo, ThrowOnError()); +} + +inline +void Myo::requestBatteryLevel() const +{ + libmyo_request_battery_level(_myo, myo::ThrowOnError()); +} + +inline +void Myo::unlock(UnlockType type) +{ + libmyo_myo_unlock(_myo, static_cast(type), ThrowOnError()); +} + +inline +void Myo::lock() +{ + libmyo_myo_lock(_myo, ThrowOnError()); +} + +inline +void Myo::notifyUserAction() +{ + libmyo_myo_notify_user_action(_myo, libmyo_user_action_single, ThrowOnError()); +} + +inline +void Myo::setStreamEmg(StreamEmgType type) +{ + libmyo_set_stream_emg(_myo, static_cast(type), ThrowOnError()); +} + +inline +libmyo_myo_t Myo::libmyoObject() const +{ + return _myo; +} + +inline +Myo::Myo(libmyo_myo_t myo) +: _myo(myo) +{ + if (!_myo) { + throw std::invalid_argument("Cannot construct Myo instance with null pointer"); + } +} + +inline +Myo::~Myo() +{ +} + +} // namespace myo diff --git a/other/myo.framework/Headers/cxx/impl/Pose_impl.hpp b/other/myo.framework/Headers/cxx/impl/Pose_impl.hpp new file mode 100755 index 0000000..7432e39 --- /dev/null +++ b/other/myo.framework/Headers/cxx/impl/Pose_impl.hpp @@ -0,0 +1,97 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_CXX_IMPL_POSE_IMPL_HPP +#define MYO_CXX_IMPL_POSE_IMPL_HPP + +#include "../Pose.hpp" + +#include + +namespace myo { + +inline +Pose::Pose() +: _type(unknown) +{ +} + +inline +Pose::Pose(Pose::Type type) +: _type(type) +{ +} + +inline +bool Pose::operator==(Pose other) const +{ + return _type == other._type; +} + +inline +bool Pose::operator!=(Pose other) const +{ + return !(*this == other); +} + +inline +Pose::Type Pose::type() const +{ + return _type; +} + +inline +bool operator==(Pose pose, Pose::Type type) +{ + return pose.type() == type; +} + +inline +bool operator==(Pose::Type type, Pose pose) +{ + return pose == type; +} + +inline +bool operator!=(Pose pose, Pose::Type type) +{ + return !(pose == type); +} + +inline +bool operator!=(Pose::Type type, Pose pose) +{ + return !(type == pose); +} + +inline +std::string Pose::toString() const +{ + switch (type()) { + case Pose::rest: + return "rest"; + case Pose::fist: + return "fist"; + case Pose::waveIn: + return "waveIn"; + case Pose::waveOut: + return "waveOut"; + case Pose::fingersSpread: + return "fingersSpread"; + case Pose::doubleTap: + return "doubleTap"; + case Pose::unknown: + return "unknown"; + } + + return ""; +} + +inline +std::ostream& operator<<(std::ostream& out, const Pose& pose) +{ + return out << pose.toString(); +} + +} // namespace myo + +#endif // MYO_CXX_IMPL_POSE_IMPL_HPP diff --git a/other/myo.framework/Headers/libmyo.h b/other/myo.framework/Headers/libmyo.h new file mode 100755 index 0000000..29a59f6 --- /dev/null +++ b/other/myo.framework/Headers/libmyo.h @@ -0,0 +1,425 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_LIBMYO_H +#define MYO_LIBMYO_H + +#include + +#include "libmyo/detail/visibility.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// @file libmyo.h +/// libmyo C API declarations. + +typedef void* libmyo_hub_t; + +/// \defgroup errors Error Handling +/// @{ + +/// Function result codes. +/// All libmyo functions that can fail return a value of this type. +typedef enum { + libmyo_success, + libmyo_error, + libmyo_error_invalid_argument, + libmyo_error_runtime +} libmyo_result_t; + +/// Opaque handle to detailed error information. +typedef void* libmyo_error_details_t; + +/// Return a null-terminated string with a detailed error message. +LIBMYO_EXPORT +const char* libmyo_error_cstring(libmyo_error_details_t); + +/// Returns the kind of error that occurred. +LIBMYO_EXPORT +libmyo_result_t libmyo_error_kind(libmyo_error_details_t); + +/// Free the resources allocated by an error object. +LIBMYO_EXPORT +void libmyo_free_error_details(libmyo_error_details_t); + +/// @} + +/// \defgroup libmyo_string Strings +/// @{ + +// Opaque string. +typedef void* libmyo_string_t; + +// Return a null-terminated string from the opaque string. +LIBMYO_EXPORT +const char* libmyo_string_c_str(libmyo_string_t); + +// Free the resources allocated by the string object. +LIBMYO_EXPORT +void libmyo_string_free(libmyo_string_t); + +/// @} + +/// \defgroup libmyo_direct_mac_addresses MAC address utilities +/// @{ + +/// Retrieve the string representation of a MAC address in hex. +/// Returns a string in the format of 00-00-00-00-00-00. +LIBMYO_EXPORT +libmyo_string_t libmyo_mac_address_to_string(uint64_t); + +/// Retrieve the MAC address from a null-terminated string in the format of 00-00-00-00-00-00. +/// Returns 0 if the string does not match the format. +LIBMYO_EXPORT +uint64_t libmyo_string_to_mac_address(const char*); + +/// @} + +/// @defgroup libmyo_hub Hub instance +/// @{ + +/// Initialize a connection to the hub. +/// \a application_identifier must follow a reverse domain name format (ex. com.domainname.appname). Application +/// identifiers can be formed from the set of alphanumeric ASCII characters (a-z, A-Z, 0-9). The hyphen (-) and +/// underscore (_) characters are permitted if they are not adjacent to a period (.) character (i.e. not at the start or +/// end of each segment), but are not permitted in the top-level domain. Application identifiers must have three or more +/// segments. For example, if a company's domain is example.com and the application is named hello-world, one could use +/// "com.example.hello-world" as a valid application identifier. \a application_identifier can be NULL or empty. +/// @returns libmyo_success if the connection is successfully established, otherwise: +/// - libmyo_error_runtime if a connection could not be established +/// - libmyo_error_invalid_argument if \a out_hub is NULL +/// - libmyo_error_invalid_argument if \a application_identifier is longer than 255 characters +/// - libmyo_error_invalid_argument if \a application_identifier is not in the proper reverse domain name format +LIBMYO_EXPORT +libmyo_result_t libmyo_init_hub(libmyo_hub_t* out_hub, const char* application_identifier, + libmyo_error_details_t* out_error); + +/// Free the resources allocated to a hub. +/// @returns libmyo_success if shutdown is successful, otherwise: +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error if \a hub is not a valid hub +LIBMYO_EXPORT +libmyo_result_t libmyo_shutdown_hub(libmyo_hub_t hub, libmyo_error_details_t* out_error); + +// Locking policies. +typedef enum { + libmyo_locking_policy_none, ///< Pose events are always sent. + libmyo_locking_policy_standard ///< Pose events are not sent while a Myo is locked. +} libmyo_locking_policy_t; + +/// Set the locking policy for Myos connected to the hub. +/// @returns libmyo_success if the locking policy is successfully set, otherwise +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error if \a hub is not a valid hub +LIBMYO_EXPORT +libmyo_result_t libmyo_set_locking_policy(libmyo_hub_t hub, libmyo_locking_policy_t locking_policy, + libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_myo Myo instances +/// @{ + +/// Opaque type corresponding to a known Myo device. +typedef void* libmyo_myo_t; + +/// Types of vibration +typedef enum { + libmyo_vibration_short, + libmyo_vibration_medium, + libmyo_vibration_long +} libmyo_vibration_type_t; + +/// Retrieve the MAC address of a Myo. +/// The MAC address is unique to the physical Myo, and is a 48-bit number. +LIBMYO_EXPORT +uint64_t libmyo_get_mac_address(libmyo_myo_t myo); + +/// Vibrate the given myo. +/// Can be called when a Myo is paired. +/// @returns libmyo_success if the Myo successfully vibrated, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_vibrate(libmyo_myo_t myo, libmyo_vibration_type_t type, libmyo_error_details_t* out_error); + +/// Request the RSSI for a given myo. +/// Can be called when a Myo is paired. A libmyo_event_rssi event will likely be generated with the value of the RSSI. +/// @returns libmyo_success if the Myo successfully got the RSSI, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_request_rssi(libmyo_myo_t myo, libmyo_error_details_t* out_error); + + +/// Request the battery level for a given Myo. +/// A libmyo_event_battery_level event will be generated with the value of the battery level. +/// @returns libmyo_success if the Myo successfully requested the battery level, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_request_battery_level(libmyo_myo_t myo_opq, libmyo_error_details_t* out_error); + +/// EMG streaming modes. +typedef enum { + libmyo_stream_emg_disabled, ///< Do not send EMG data. + libmyo_stream_emg_enabled ///< Send EMG data. +} libmyo_stream_emg_t; + +/// Set whether or not to stream EMG data for a given myo. +/// Can be called when a Myo is paired. +/// @returns libmyo_success if the EMG mode was set successfully, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_set_stream_emg(libmyo_myo_t myo, libmyo_stream_emg_t emg, libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_poses Pose recognition. +/// @{ + +/// Supported poses. +typedef enum { + libmyo_pose_rest = 0, ///< Rest pose. + libmyo_pose_fist = 1, ///< User is making a fist. + libmyo_pose_wave_in = 2, ///< User has an open palm rotated towards the posterior of their wrist. + libmyo_pose_wave_out = 3, ///< User has an open palm rotated towards the anterior of their wrist. + libmyo_pose_fingers_spread = 4, ///< User has an open palm with their fingers spread away from each other. + libmyo_pose_double_tap = 5, ///< User tapped their thumb and middle finger together twice in succession. + + libmyo_num_poses, ///< Number of poses supported; not a valid pose. + + libmyo_pose_unknown = 0xffff ///< Unknown pose. +} libmyo_pose_t; + +/// @} + +/// @defgroup libmyo_locking Myo locking mechanism + +/// Valid unlock types. +typedef enum { + libmyo_unlock_timed = 0, ///< Unlock for a fixed period of time. + libmyo_unlock_hold = 1, ///< Unlock until explicitly told to re-lock. +} libmyo_unlock_type_t; + +/// Unlock the given Myo. +/// Can be called when a Myo is paired. A libmyo_event_unlocked event will be generated if the Myo was locked. +/// @returns libmyo_success if the Myo was successfully unlocked, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_unlock(libmyo_myo_t myo, libmyo_unlock_type_t type, libmyo_error_details_t* out_error); + +/// Lock the given Myo immediately. +/// Can be called when a Myo is paired. A libmyo_event_locked event will be generated if the Myo was unlocked. +/// @returns libmyo_success if the Myo was successfully locked, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_lock(libmyo_myo_t myo, libmyo_error_details_t* out_error); + +/// User action types. +typedef enum { + libmyo_user_action_single = 0, ///< User did a single, discrete action, such as pausing a video. +} libmyo_user_action_type_t; + +/// Notify the given Myo that a user action was recognized. +/// Can be called when a Myo is paired. Will cause Myo to vibrate. +/// @returns libmyo_success if the Myo was successfully notified, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_notify_user_action(libmyo_myo_t myo, libmyo_user_action_type_t type, + libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_events Event Handling +/// @{ + +/// Types of events. +typedef enum { + libmyo_event_paired, ///< Successfully paired with a Myo. + libmyo_event_unpaired, ///< Successfully unpaired from a Myo. + libmyo_event_connected, ///< A Myo has successfully connected. + libmyo_event_disconnected, ///< A Myo has been disconnected. + libmyo_event_arm_synced, ///< A Myo has recognized that the sync gesture has been successfully performed. + libmyo_event_arm_unsynced, ///< A Myo has been moved or removed from the arm. + libmyo_event_orientation, ///< Orientation data has been received. + libmyo_event_pose, ///< A change in pose has been detected. @see libmyo_pose_t. + libmyo_event_rssi, ///< An RSSI value has been received. + libmyo_event_unlocked, ///< A Myo has become unlocked. + libmyo_event_locked, ///< A Myo has become locked. + libmyo_event_emg, ///< EMG data has been received. + libmyo_event_battery_level, ///< A battery level value has been received. + libmyo_event_warmup_completed, ///< The warmup period has completed. +} libmyo_event_type_t; + +/// Information about an event. +typedef const void* libmyo_event_t; + +/// Retrieve the type of an event. +LIBMYO_EXPORT +uint32_t libmyo_event_get_type(libmyo_event_t event); + +/// Retrieve the timestamp of an event. +/// @see libmyo_now() for details on timestamps. +LIBMYO_EXPORT +uint64_t libmyo_event_get_timestamp(libmyo_event_t event); + +/// Retrieve the Myo associated with an event. +LIBMYO_EXPORT +libmyo_myo_t libmyo_event_get_myo(libmyo_event_t event); + +/// Retrieve the MAC address of the myo associated with an event. +LIBMYO_EXPORT +uint64_t libmyo_event_get_mac_address(libmyo_event_t event_opq); + +/// Retrieve the name of the myo associated with an event. +/// Caller must free the returned string. @see libmyo_string functions. +LIBMYO_EXPORT +libmyo_string_t libmyo_event_get_myo_name(libmyo_event_t event); + +/// Components of version. +typedef enum { + libmyo_version_major, ///< Major version. + libmyo_version_minor, ///< Minor version. + libmyo_version_patch, ///< Patch version. + libmyo_version_hardware_rev, ///< Hardware revision. +} libmyo_version_component_t; + +/// Hardware revisions. +typedef enum { + libmyo_hardware_rev_c = 1, ///< Alpha units + libmyo_hardware_rev_d = 2, ///< Consumer units +} libmyo_hardware_rev_t; + +/// Retrieve the Myo armband's firmware version from this event. +/// Valid for libmyo_event_paired and libmyo_event_connected events. +LIBMYO_EXPORT +unsigned int libmyo_event_get_firmware_version(libmyo_event_t event, libmyo_version_component_t); + +/// Enumeration identifying a right arm or left arm. @see libmyo_event_get_arm(). +typedef enum { + libmyo_arm_right, ///< Myo is on the right arm. + libmyo_arm_left, ///< Myo is on the left arm. + libmyo_arm_unknown, ///< Unknown arm. +} libmyo_arm_t; + +/// Retrieve the arm associated with an event. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_arm_t libmyo_event_get_arm(libmyo_event_t event); + +/// Possible directions for Myo's +x axis relative to a user's arm. +typedef enum { + libmyo_x_direction_toward_wrist, ///< Myo's +x axis is pointing toward the user's wrist. + libmyo_x_direction_toward_elbow, ///< Myo's +x axis is pointing toward the user's elbow. + libmyo_x_direction_unknown, ///< Unknown +x axis direction. +} libmyo_x_direction_t; + +/// Retrieve the x-direction associated with an event. +/// The x-direction specifies which way Myo's +x axis is pointing relative to the user's arm. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_x_direction_t libmyo_event_get_x_direction(libmyo_event_t event); + +/// Possible warmup states for Myo. +typedef enum { + libmyo_warmup_state_unknown = 0, ///< Unknown warm up state. + libmyo_warmup_state_cold = 1, ///< Myo needs to warm up. + libmyo_warmup_state_warm = 2, ///< Myo is already in a warmed up state. +} libmyo_warmup_state_t; + +/// Retrieve the warmup state of the Myo associated with an event. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_warmup_state_t libmyo_event_get_warmup_state(libmyo_event_t event); + +/// Possible warmup results for Myo. +typedef enum { + libmyo_warmup_result_unknown = 0, ///< Unknown warm up result. + libmyo_warmup_result_success = 1, ///< The warm up period has completed successfully. + libmyo_warmup_result_failed_timeout = 2, ///< The warm up period timed out. +} libmyo_warmup_result_t; + +/// Retrieve the warmup result of the Myo associated with an event. +/// Valid for libmyo_event_warmup_completed events only. +LIBMYO_EXPORT +libmyo_warmup_result_t libmyo_event_get_warmup_result(libmyo_event_t event); + +/// Retrieve the estimated rotation of Myo on the user's arm after a sync. +/// The values specifies the rotation of the myo on the arm (0 - logo facing down, pi - logo facing up) +/// Only supported by FW 1.3.x and above (older firmware will always report 0 for the rotation) +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +float libmyo_event_get_rotation_on_arm(libmyo_event_t event); + +/// Index into orientation data, which is provided as a quaternion. +/// Orientation data is returned as a unit quaternion of floats, represented as `w + x * i + y * j + z * k`. +typedef enum { + libmyo_orientation_x = 0, ///< First component of the quaternion's vector part + libmyo_orientation_y = 1, ///< Second component of the quaternion's vector part + libmyo_orientation_z = 2, ///< Third component of the quaternion's vector part + libmyo_orientation_w = 3, ///< Scalar component of the quaternion. +} libmyo_orientation_index; + +/// Retrieve orientation data associated with an event. +/// Valid for libmyo_event_orientation events only. +/// @see libmyo_orientation_index +LIBMYO_EXPORT +float libmyo_event_get_orientation(libmyo_event_t event, libmyo_orientation_index index); + +/// Retrieve raw accelerometer data associated with an event in units of g. +/// Valid for libmyo_event_orientation events only. +/// Requires `index < 3`. +LIBMYO_EXPORT +float libmyo_event_get_accelerometer(libmyo_event_t event, unsigned int index); + +/// Retrieve raw gyroscope data associated with an event in units of deg/s. +/// Valid for libmyo_event_orientation events only. +/// Requires `index < 3`. +LIBMYO_EXPORT +float libmyo_event_get_gyroscope(libmyo_event_t event, unsigned int index); + +/// Retrieve the pose associated with an event. +/// Valid for libmyo_event_pose events only. +LIBMYO_EXPORT +libmyo_pose_t libmyo_event_get_pose(libmyo_event_t event); + +/// Retreive the RSSI associated with an event. +/// Valid for libmyo_event_rssi events only. +LIBMYO_EXPORT +int8_t libmyo_event_get_rssi(libmyo_event_t event); + +/// Retrieve the battery level of the Myo armband associated with an event. +/// Only valid for libmyo_event_battery_level event. +LIBMYO_EXPORT +uint8_t libmyo_event_get_battery_level(libmyo_event_t event); + +/// Retrieve an EMG data point associated with an event. +/// Valid for libmyo_event_emg events only. +/// @a sensor must be smaller than 8. +LIBMYO_EXPORT +int8_t libmyo_event_get_emg(libmyo_event_t event, unsigned int sensor); + +/// Return type for event handlers. +typedef enum { + libmyo_handler_continue, ///< Continue processing events + libmyo_handler_stop, ///< Stop processing events +} libmyo_handler_result_t; + +/// Callback function type to handle events as they occur from libmyo_run(). +typedef libmyo_handler_result_t (*libmyo_handler_t)(void* user_data, libmyo_event_t event); + +/// Process events and call the provided callback as they occur. +/// Runs for up to approximately \a duration_ms milliseconds or until a called handler returns libmyo_handler_stop. +/// @returns libmyo_success after a successful run, otherwise +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error_invalid_argument if \a handler is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_run(libmyo_hub_t hub, unsigned int duration_ms, libmyo_handler_t handler, void* user_data, + libmyo_error_details_t* out_error); + +/// @} + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // MYO_LIBMYO_H diff --git a/other/myo.framework/Headers/libmyo/detail/visibility.h b/other/myo.framework/Headers/libmyo/detail/visibility.h new file mode 100755 index 0000000..3a23e6a --- /dev/null +++ b/other/myo.framework/Headers/libmyo/detail/visibility.h @@ -0,0 +1,32 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_LIBMYO_DETAIL_VISIBILITY_H +#define MYO_LIBMYO_DETAIL_VISIBILITY_H + +#if defined(_WIN32) || defined(__CYGWIN__) + #ifdef myo_EXPORTS + #ifdef __GNUC__ + #define LIBMYO_EXPORT __attribute__ ((dllexport)) + #else + #define LIBMYO_EXPORT __declspec(dllexport) + #endif + #else + #ifdef LIBMYO_STATIC_BUILD + #define LIBMYO_EXPORT + #else + #ifdef __GNUC__ + #define LIBMYO_EXPORT __attribute__ ((dllimport)) + #else + #define LIBMYO_EXPORT __declspec(dllimport) + #endif + #endif + #endif +#else + #if __GNUC__ >= 4 + #define LIBMYO_EXPORT __attribute__ ((visibility ("default"))) + #else + #define LIBMYO_EXPORT + #endif +#endif + +#endif // MYO_LIBMYO_DETAIL_VISIBILITY_H diff --git a/other/myo.framework/Headers/myo.hpp b/other/myo.framework/Headers/myo.hpp new file mode 100755 index 0000000..5ea17fb --- /dev/null +++ b/other/myo.framework/Headers/myo.hpp @@ -0,0 +1,13 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +/// The namespace in which all of the %Myo C++ bindings are contained. +namespace myo {} + +#include "cxx/DeviceListener.hpp" +#include "cxx/Hub.hpp" +#include "cxx/Myo.hpp" +#include "cxx/Pose.hpp" +#include "cxx/Quaternion.hpp" +#include "cxx/Vector3.hpp" diff --git a/other/myo.framework/Resources/Info.plist b/other/myo.framework/Resources/Info.plist new file mode 100755 index 0000000..aeec5cc --- /dev/null +++ b/other/myo.framework/Resources/Info.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + myo + CFBundleIconFile + + CFBundleIdentifier + + CFBundleInfoDictionaryVersion + 6.0 + CFBundlePackageType + FMWK + CFBundleSignature + ???? + CFBundleVersion + + CFBundleShortVersionString + + CSResourcesFileMapped + + + diff --git a/other/myo.framework/Versions/A/Headers/cxx/DeviceListener.hpp b/other/myo.framework/Versions/A/Headers/cxx/DeviceListener.hpp new file mode 100755 index 0000000..816cab3 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/DeviceListener.hpp @@ -0,0 +1,197 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include "Pose.hpp" + +namespace myo { + +class Myo; +template +class Quaternion; +template +class Vector3; + +/// Enumeration identifying a right arm or left arm. +enum Arm { + armLeft = libmyo_arm_left, + armRight = libmyo_arm_right, + armUnknown = libmyo_arm_unknown +}; + +/// Possible directions for Myo's +x axis relative to a user's arm. +enum XDirection { + xDirectionTowardWrist = libmyo_x_direction_toward_wrist, + xDirectionTowardElbow = libmyo_x_direction_toward_elbow, + xDirectionUnknown = libmyo_x_direction_unknown +}; + +/// Possible warmup states for a Myo. +enum WarmupState { + warmupStateUnknown = libmyo_warmup_state_unknown, + warmupStateCold = libmyo_warmup_state_cold, + warmupStateWarm = libmyo_warmup_state_warm, +}; + +/// Possible warmup results for a Myo. +enum WarmupResult { + warmupResultUnknown = libmyo_warmup_result_unknown, + warmupResultSuccess = libmyo_warmup_result_success, + warmupResultFailedTimeout = libmyo_warmup_result_failed_timeout, +}; + +/// Firmware version of Myo. +struct FirmwareVersion { + unsigned int firmwareVersionMajor; ///< Myo's major version must match the required major version. + unsigned int firmwareVersionMinor; ///< Myo's minor version must match the required minor version. + unsigned int firmwareVersionPatch; ///< Myo's patch version must greater or equal to the required patch version. + unsigned int firmwareVersionHardwareRev; ///< Myo's hardware revision; not used to detect firmware version mismatch. +}; + +/// A DeviceListener receives events about a Myo. +/// @see Hub::addListener() +class DeviceListener { +public: + virtual ~DeviceListener() {} + + /// Called when a Myo has been paired. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param firmwareVersion The firmware version of \a myo. + virtual void onPair(Myo* myo, uint64_t timestamp, FirmwareVersion firmwareVersion) {} + + /// Called when a Myo has been unpaired. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onUnpair(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo has been connected. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param firmwareVersion The firmware version of \a myo. + virtual void onConnect(Myo* myo, uint64_t timestamp, FirmwareVersion firmwareVersion) {} + + /// Called when a paired Myo has been disconnected. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onDisconnect(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo recognizes that it is on an arm. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param arm The identified Arm of \a myo. + /// @param xDirection The identified XDirection of \a myo. + /// @param rotation The estimated rotation of Myo on the user's arm after a sync. + /// @param warmupState The warmup state of \a myo. If \a warmupState is equal to WarmupState::warmupStateCold, + /// onWarmupCompleted() will be called when the warmup period has completed. + virtual void onArmSync(Myo* myo, uint64_t timestamp, Arm arm, XDirection xDirection, float rotation, + WarmupState warmupState) {} + + /// Called when a paired Myo is moved or removed from the arm. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onArmUnsync(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo becomes unlocked. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onUnlock(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo becomes locked. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onLock(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo has provided a new pose. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param pose The identified Pose of \a myo. + virtual void onPose(Myo* myo, uint64_t timestamp, Pose pose) {} + + /// Called when a paired Myo has provided new orientation data. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param rotation The orientation data of \a myo, as a Quaternion. + virtual void onOrientationData(Myo* myo, uint64_t timestamp, const Quaternion& rotation) {} + + /// Called when a paired Myo has provided new accelerometer data in units of g. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param accel The accelerometer data of \a myo, in units of g. + virtual void onAccelerometerData(Myo* myo, uint64_t timestamp, const Vector3& accel) {} + + /// Called when a paired Myo has provided new gyroscope data in units of deg/s. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param gyro The gyroscope data of \a myo, in units of deg/s. + virtual void onGyroscopeData(Myo* myo, uint64_t timestamp, const Vector3& gyro) {} + + /// Called when a paired Myo has provided a new RSSI value. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param rssi The RSSI (received signal strength indication) of \a myo. + /// @see Myo::requestRssi() to request an RSSI value from the Myo. + virtual void onRssi(Myo* myo, uint64_t timestamp, int8_t rssi) {} + + /// Called when a paired Myo receives an battery level update. + /// Updates occur when the battery level changes and when the battery level is explicitly requested. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param level battery level reported by the myo the value is a number from 0 to 100 representing the percentage + /// of battery life remaining. + virtual void onBatteryLevelReceived(myo::Myo* myo, uint64_t timestamp, uint8_t level) {} + + /// Called when a paired Myo has provided new EMG data. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param emg An array of 8 elements, each corresponding to one sensor. + virtual void onEmgData(myo::Myo* myo, uint64_t timestamp, const int8_t* emg) {} + + /// Called when the warmup period for a Myo has completed. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param warmupResult The warmup result of \a myo. + virtual void onWarmupCompleted(myo::Myo* myo, uint64_t timestamp, WarmupResult warmupResult) {} + + /// @cond LIBMYO_INTERNALS + + virtual void onOpaqueEvent(libmyo_event_t event) {} + + /// @endcond +}; + +} // namespace myo diff --git a/other/myo.framework/Versions/A/Headers/cxx/Hub.hpp b/other/myo.framework/Versions/A/Headers/cxx/Hub.hpp new file mode 100755 index 0000000..1d4a3e0 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/Hub.hpp @@ -0,0 +1,91 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include + +namespace myo { + +class Myo; +class DeviceListener; + +/// @brief A Hub provides access to one or more Myo instances. +class Hub { +public: + /// Construct a hub. + /// \a applicationIdentifier must follow a reverse domain name format (ex. com.domainname.appname). Application + /// identifiers can be formed from the set of alphanumeric ASCII characters (a-z, A-Z, 0-9). The hyphen (-) and + /// underscore (_) characters are permitted if they are not adjacent to a period (.) character (i.e. not at the + /// start or end of each segment), but are not permitted in the top-level domain. Application identifiers must have + /// three or more segments. For example, if a company's domain is example.com and the application is named + /// hello-world, one could use "com.example.hello-world" as a valid application identifier. \a applicationIdentifier + /// can be an empty string. + /// Throws an exception of type std::invalid_argument if \a applicationIdentifier is not in the proper reverse + /// domain name format or is longer than 255 characters. + /// Throws an exception of type std::runtime_error if the hub initialization failed for some reason, typically + /// because Myo Connect is not running and a connection can thus not be established. + Hub(const std::string& applicationIdentifier = ""); + + /// Deallocate any resources associated with a Hub. + /// This will cause all Myo instances retrieved from this Hub to become invalid. + ~Hub(); + + /// Wait for a Myo to become paired, or time out after \a timeout_ms milliseconds if provided. + /// If \a timeout_ms is zero, this function blocks until a Myo is found. + /// This function must not be called concurrently with run() or runOnce(). + Myo* waitForMyo(unsigned int milliseconds = 0); + + /// Register a listener to be called when device events occur. + void addListener(DeviceListener* listener); + + /// Remove a previously registered listener. + void removeListener(DeviceListener* listener); + + /// Locking policies supported by Myo. + enum LockingPolicy { + lockingPolicyNone = libmyo_locking_policy_none, + lockingPolicyStandard = libmyo_locking_policy_standard + }; + + /// Set the locking policy for Myos connected to the Hub. + void setLockingPolicy(LockingPolicy lockingPolicy); + + /// Run the event loop for the specified duration (in milliseconds). + void run(unsigned int duration_ms); + + /// Run the event loop until a single event occurs, or the specified duration (in milliseconds) has elapsed. + void runOnce(unsigned int duration_ms); + + /// @cond MYO_INTERNALS + + /// Return the internal libmyo object corresponding to this hub. + libmyo_hub_t libmyoObject(); + +protected: + void onDeviceEvent(libmyo_event_t event); + + Myo* lookupMyo(libmyo_myo_t opaqueMyo) const; + + Myo* addMyo(libmyo_myo_t opaqueMyo); + + libmyo_hub_t _hub; + std::vector _myos; + std::vector _listeners; + + /// @endcond + +private: + // Not implemented + Hub(const Hub&); + Hub& operator=(const Hub&); +}; + +/// @example hello-myo.cpp +/// @example multiple-myos.cpp +/// @example emg-data-sample.cpp + +} // namespace myo + +#include "impl/Hub_impl.hpp" diff --git a/other/myo.framework/Versions/A/Headers/cxx/Myo.hpp b/other/myo.framework/Versions/A/Headers/cxx/Myo.hpp new file mode 100755 index 0000000..c030e09 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/Myo.hpp @@ -0,0 +1,83 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +namespace myo { + +/// Represents a Myo device with a specific MAC address. +/// This class can not be instantiated directly; instead, use Hub to get access to a Myo. +/// There is only one Myo instance corresponding to each device; thus, if the addresses of two Myo instances compare +/// equal, they refer to the same device. +class Myo { +public: + /// Types of vibration supported by the Myo. + enum VibrationType { + vibrationShort = libmyo_vibration_short, + vibrationMedium = libmyo_vibration_medium, + vibrationLong = libmyo_vibration_long + }; + + /// Vibrate the Myo. + void vibrate(VibrationType type); + + /// Request the RSSI of the Myo. An onRssi event will likely be generated with the value of the RSSI. + /// @see DeviceListener::onRssi() + void requestRssi() const; + + /// Request the battery level of the Myo. An onBatteryLevelReceived event will be generated with the value. + /// @see DeviceListener::onBatteryLevelReceived(). + void requestBatteryLevel() const; + + /// Unlock types supported by Myo. + enum UnlockType { + unlockTimed = libmyo_unlock_timed, + unlockHold = libmyo_unlock_hold + }; + + /// Unlock the Myo. + /// Myo will remain unlocked for a short amount of time, after which it will automatically lock again. + /// If Myo was locked, an onUnlock event will be generated. + void unlock(UnlockType type); + + /// Force the Myo to lock immediately. + /// If Myo was unlocked, an onLock event will be generated. + void lock(); + + /// Notify the Myo that a user action was recognized. + /// Will cause Myo to vibrate. + void notifyUserAction(); + + /// Valid EMG streaming modes for a Myo. + enum StreamEmgType { + streamEmgDisabled = libmyo_stream_emg_disabled, + streamEmgEnabled = libmyo_stream_emg_enabled + }; + + /// Sets the EMG streaming mode for a Myo. + void setStreamEmg(StreamEmgType type); + + /// @cond MYO_INTERNALS + + /// Return the internal libmyo object corresponding to this device. + libmyo_myo_t libmyoObject() const; + + /// @endcond + +private: + Myo(libmyo_myo_t myo); + ~Myo(); + + libmyo_myo_t _myo; + + // Not implemented. + Myo(const Myo&); + Myo& operator=(const Myo&); + + friend class Hub; +}; + +} // namespace myo + +#include "impl/Myo_impl.hpp" diff --git a/other/myo.framework/Versions/A/Headers/cxx/Pose.hpp b/other/myo.framework/Versions/A/Headers/cxx/Pose.hpp new file mode 100755 index 0000000..8d668b4 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/Pose.hpp @@ -0,0 +1,70 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include +#include + +#include + +namespace myo { + +/// A pose represents a detected configuration of the user's hand. +class Pose { +public: + /// Types of poses supported by the SDK. + enum Type { + rest = libmyo_pose_rest, + fist = libmyo_pose_fist, + waveIn = libmyo_pose_wave_in, + waveOut = libmyo_pose_wave_out, + fingersSpread = libmyo_pose_fingers_spread, + doubleTap = libmyo_pose_double_tap, + unknown = libmyo_pose_unknown + }; + + /// Construct a pose of type Pose::none. + Pose(); + + /// Construct a pose with the given type. + Pose(Type type); + + /// Returns true if and only if the two poses are of the same type. + bool operator==(Pose other) const; + + /// Equivalent to `!(*this == other)`. + bool operator!=(Pose other) const; + + /// Returns the type of this pose. + Type type() const; + + /// Return a human-readable string representation of the pose. + std::string toString() const; + +private: + Type _type; +}; + +/// @relates Pose +/// Returns true if and only if the type of pose is the same as the provided type. +bool operator==(Pose pose, Pose::Type t); + +/// @relates Pose +/// Equivalent to `pose == type`. +bool operator==(Pose::Type type, Pose pose); + +/// @relates Pose +/// Equivalent to `!(pose == type)`. +bool operator!=(Pose pose, Pose::Type type); + +/// @relates Pose +/// Equivalent to `!(type == pose)`. +bool operator!=(Pose::Type type, Pose pose); + +/// @relates Pose +/// Write the name of the provided pose to the provided output stream. +std::ostream& operator<<(std::ostream& out, const Pose& pose); + +} // namespace myo + +#include "impl/Pose_impl.hpp" diff --git a/other/myo.framework/Versions/A/Headers/cxx/Quaternion.hpp b/other/myo.framework/Versions/A/Headers/cxx/Quaternion.hpp new file mode 100755 index 0000000..6e56df3 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/Quaternion.hpp @@ -0,0 +1,158 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include "Vector3.hpp" + +namespace myo { + +/// A quaternion that can be used to represent a rotation. +/// This type provides only very basic functionality to store quaternions that's sufficient to retrieve the data to +/// be placed in a full featured quaternion type. +template +class Quaternion { + public: + /// Construct a quaternion that represents zero rotation (i.e. the multiplicative identity). + Quaternion() + : _x(0) + , _y(0) + , _z(0) + , _w(1) + { + } + + /// Construct a quaternion with the provided components. + Quaternion(T x, T y, T z, T w) + : _x(x) + , _y(y) + , _z(z) + , _w(w) + { + } + + /// Set the components of this quaternion to be those of the other. + Quaternion& operator=(const Quaternion other) + { + _x = other._x; + _y = other._y; + _z = other._z; + _w = other._w; + + return *this; + } + + /// Return the x-component of this quaternion's vector. + T x() const { return _x; } + + /// Return the y-component of this quaternion's vector. + T y() const { return _y; } + + /// Return the z-component of this quaternion's vector. + T z() const { return _z; } + + /// Return the w-component (scalar) of this quaternion. + T w() const { return _w; } + + /// Return the quaternion multiplied by \a rhs. + /// Note that quaternion multiplication is not commutative. + Quaternion operator*(const Quaternion& rhs) const + { + return Quaternion( + _w * rhs._x + _x * rhs._w + _y * rhs._z - _z * rhs._y, + _w * rhs._y - _x * rhs._z + _y * rhs._w + _z * rhs._x, + _w * rhs._z + _x * rhs._y - _y * rhs._x + _z * rhs._w, + _w * rhs._w - _x * rhs._x - _y * rhs._y - _z * rhs._z + ); + } + + /// Multiply this quaternion by \a rhs. + /// Return this quaternion updated with the result. + Quaternion& operator*=(const Quaternion& rhs) + { + *this = *this * rhs; + return *this; + } + + /// Return the unit quaternion corresponding to the same rotation as this one. + Quaternion normalized() const + { + T magnitude = std::sqrt(_x * _x + _y * _y + _z * _z + _w * _w); + + return Quaternion(_x / magnitude, _y / magnitude, _z / magnitude, _w / magnitude); + } + + /// Return this quaternion's conjugate. + Quaternion conjugate() const + { + return Quaternion(-_x, -_y, -_z, _w); + } + + /// Return a quaternion that represents a right-handed rotation of \a angle radians about the given \a axis. + /// \a axis The unit vector representing the axis of rotation. + /// \a angle The angle of rotation, in radians. + static Quaternion fromAxisAngle(const myo::Vector3& axis, T angle) + { + return Quaternion(axis.x() * std::sin(angle / 2), + axis.y() * std::sin(angle / 2), + axis.z() * std::sin(angle / 2), + std::cos(angle / 2)); + } + + private: + T _x, _y, _z, _w; +}; + +/// Return a copy of this \a vec rotated by \a quat. +/// \relates myo::Quaternion +template +Vector3 rotate(const Quaternion& quat, const Vector3& vec) +{ + myo::Quaternion qvec(vec.x(), vec.y(), vec.z(), 0); + myo::Quaternion result = quat * qvec * quat.conjugate(); + return Vector3(result.x(), result.y(), result.z()); +} + +/// Return a quaternion that represents a rotation from vector \a from to \a to. +/// \relates myo::Quaternion +/// See http://stackoverflow.com/questions/1171849/finding-quaternion-representing-the-rotation-from-one-vector-to-another +/// for some explanation. +template +Quaternion rotate(const Vector3& from, const Vector3& to) +{ + Vector3 cross = from.cross(to); + + // The product of the square of magnitudes and the cosine of the angle between from and to. + T cosTheta = from.dot(to); + + // Return identity if the vectors are the same direction. + if (cosTheta >= 1) { + return Quaternion(); + } + + // The product of the square of the magnitudes + T k = std::sqrt(from.dot(from) * to.dot(to)); + + // Return identity in the degenerate case. + if (k <= 0) { + return Quaternion(); + } + + // Special handling for vectors facing opposite directions. + if (cosTheta / k <= -1) { + Vector3 xAxis(1, 0, 0); + Vector3 yAxis(0, 1, 0); + + cross = from.cross(std::abs(from.dot(xAxis)) < 1 ? xAxis : yAxis); + k = cosTheta = 0; + } + + return Quaternion( + cross.x(), + cross.y(), + cross.z(), + k + cosTheta); +} + +} // namespace myo diff --git a/other/myo.framework/Versions/A/Headers/cxx/Vector3.hpp b/other/myo.framework/Versions/A/Headers/cxx/Vector3.hpp new file mode 100755 index 0000000..774654b --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/Vector3.hpp @@ -0,0 +1,103 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#define _USE_MATH_DEFINES +#include + +namespace myo { + +/// A vector of three components. +/// This type provides very basic functionality to store a three dimensional vector that's sufficient to retrieve +/// the data to be placed in a full featured vector type. A few common vector operations, such as dot product and +/// cross product, are also provided. +template +class Vector3 { + public: + /// Construct a vector of all zeroes. + Vector3() + { + _data[0] = 0; + _data[1] = 0; + _data[2] = 0; + } + + /// Construct a vector with the three provided components. + Vector3(T x, T y, T z) + { + _data[0] = x; + _data[1] = y; + _data[2] = z; + } + + /// Construct a vector with the same components as \a other. + Vector3(const Vector3& other) + { + *this = other; + } + + /// Set the components of this vector to be the same as \a other. + Vector3& operator=(const Vector3& other) + { + _data[0] = other._data[0]; + _data[1] = other._data[1]; + _data[2] = other._data[2]; + + return *this; + } + + /// Return a copy of the component of this vector at \a index, which should be 0, 1, or 2. + T operator[](unsigned int index) const + { + return _data[index]; + } + + /// Return the x-component of this vector. + T x() const { return _data[0]; } + + /// Return the y-component of this vector. + T y() const { return _data[1]; } + + /// Return the z-component of this vector. + T z() const { return _data[2]; } + + /// Return the magnitude of this vector. + T magnitude() const + { + return std::sqrt(x() * x() + y() * y() + z() * z()); + } + + /// Return a normalized copy of this vector. + Vector3 normalized() const + { + T norm = magnitude(); + return Vector3(x() / norm, y() / norm, z() / norm); + } + + /// Return the dot product of this vector and \a rhs. + T dot(const Vector3& rhs) const + { + return x() * rhs.x() + y() * rhs.y() + z() * rhs.z(); + } + + /// Return the cross product of this vector and \a rhs. + Vector3 cross(const Vector3& rhs) const + { + return Vector3( + y() * rhs.z() - z() * rhs.y(), + z() * rhs.x() - x() * rhs.z(), + x() * rhs.y() - y() * rhs.x() + ); + } + + /// Return the angle between this vector and \a rhs, in radians. + T angleTo(const Vector3& rhs) const + { + return std::acos(dot(rhs) / (magnitude() * rhs.magnitude())); + } + + private: + T _data[3]; +}; + +} // namespace myo diff --git a/other/myo.framework/Versions/A/Headers/cxx/detail/ThrowOnError.hpp b/other/myo.framework/Versions/A/Headers/cxx/detail/ThrowOnError.hpp new file mode 100755 index 0000000..3be0f3f --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/detail/ThrowOnError.hpp @@ -0,0 +1,70 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_CXX_DETAIL_THROWONERROR_HPP +#define MYO_CXX_DETAIL_THROWONERROR_HPP + +#include + +#include + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +#define LIBMYO_NOEXCEPT(b) +#else +#if __cplusplus >= 201103L +# define LIBMYO_NOEXCEPT(b) noexcept(b) +#else +# define LIBMYO_NOEXCEPT(b) +#endif +#endif + +namespace myo { + +class ThrowOnError { +public: + ThrowOnError() + : _error() + { + } + + ~ThrowOnError() LIBMYO_NOEXCEPT(false) + { + if (_error) + { + switch (libmyo_error_kind(_error)) { + case libmyo_error: + case libmyo_error_runtime: + { + std::runtime_error exception(libmyo_error_cstring(_error)); + libmyo_free_error_details(_error); + throw exception; + } + case libmyo_error_invalid_argument: + { + std::invalid_argument exception(libmyo_error_cstring(_error)); + libmyo_free_error_details(_error); + throw exception; + } + case libmyo_success: + { + break; + } + } + } + } + + operator libmyo_error_details_t*() + { + return &_error; + } + +private: + libmyo_error_details_t _error; + + // Not implemented + ThrowOnError(const ThrowOnError&); // = delete; + ThrowOnError& operator=(const ThrowOnError&); // = delete; +}; + +} //namespace libmyo + +#endif // MYO_CXX_DETAIL_THROWONERROR_HPP diff --git a/other/myo.framework/Versions/A/Headers/cxx/impl/Hub_impl.hpp b/other/myo.framework/Versions/A/Headers/cxx/impl/Hub_impl.hpp new file mode 100755 index 0000000..5e5244e --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/impl/Hub_impl.hpp @@ -0,0 +1,265 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#include "../Hub.hpp" + +#include +#include + +#include "../DeviceListener.hpp" +#include "../Myo.hpp" +#include "../Pose.hpp" +#include "../Quaternion.hpp" +#include "../Vector3.hpp" +#include "../detail/ThrowOnError.hpp" + +namespace myo { + +inline +Hub::Hub(const std::string& applicationIdentifier) +: _hub(0) +, _myos() +, _listeners() +{ + libmyo_init_hub(&_hub, applicationIdentifier.c_str(), ThrowOnError()); +} + +inline +Hub::~Hub() +{ + for (std::vector::iterator I = _myos.begin(), IE = _myos.end(); I != IE; ++I) { + delete *I; + } + libmyo_shutdown_hub(_hub, 0); +} + +inline +Myo* Hub::waitForMyo(unsigned int timeout_ms) +{ + std::size_t prevSize = _myos.size(); + + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + libmyo_myo_t opaque_myo = libmyo_event_get_myo(event); + + switch (libmyo_event_get_type(event)) { + case libmyo_event_paired: + hub->addMyo(opaque_myo); + return libmyo_handler_stop; + default: + break; + } + + return libmyo_handler_continue; + } + }; + + do { + libmyo_run(_hub, timeout_ms ? timeout_ms : 1000, &local::handler, this, ThrowOnError()); + } while (!timeout_ms && _myos.size() <= prevSize); + + if (_myos.size() <= prevSize) { + return 0; + } + + return _myos.back(); +} + +inline +void Hub::addListener(DeviceListener* listener) +{ + if (std::find(_listeners.begin(), _listeners.end(), listener) != _listeners.end()) { + // Listener was already added. + return; + } + _listeners.push_back(listener); +} + +inline +void Hub::removeListener(DeviceListener* listener) +{ + std::vector::iterator I = std::find(_listeners.begin(), _listeners.end(), listener); + if (I == _listeners.end()) { + // Don't have this listener. + return; + } + + _listeners.erase(I); +} + +inline +void Hub::setLockingPolicy(LockingPolicy lockingPolicy) +{ + libmyo_set_locking_policy(_hub, static_cast(lockingPolicy), ThrowOnError()); +} + +inline +void Hub::onDeviceEvent(libmyo_event_t event) +{ + libmyo_myo_t opaqueMyo = libmyo_event_get_myo(event); + + Myo* myo = lookupMyo(opaqueMyo); + + if (!myo && libmyo_event_get_type(event) == libmyo_event_paired) { + myo = addMyo(opaqueMyo); + } + + if (!myo) { + // Ignore events for Myos we don't know about. + return; + } + + for (std::vector::iterator I = _listeners.begin(), IE = _listeners.end(); I != IE; ++I) { + DeviceListener* listener = *I; + + listener->onOpaqueEvent(event); + + uint64_t time = libmyo_event_get_timestamp(event); + + switch (libmyo_event_get_type(event)) { + case libmyo_event_paired: { + FirmwareVersion version = {libmyo_event_get_firmware_version(event, libmyo_version_major), + libmyo_event_get_firmware_version(event, libmyo_version_minor), + libmyo_event_get_firmware_version(event, libmyo_version_patch), + libmyo_event_get_firmware_version(event, libmyo_version_hardware_rev)}; + listener->onPair(myo, time, version); + break; + } + case libmyo_event_unpaired: + listener->onUnpair(myo, time); + break; + case libmyo_event_connected: { + FirmwareVersion version = {libmyo_event_get_firmware_version(event, libmyo_version_major), + libmyo_event_get_firmware_version(event, libmyo_version_minor), + libmyo_event_get_firmware_version(event, libmyo_version_patch), + libmyo_event_get_firmware_version(event, libmyo_version_hardware_rev)}; + listener->onConnect(myo, time, version); + break; + } + case libmyo_event_disconnected: + listener->onDisconnect(myo, time); + break; + case libmyo_event_arm_synced: + listener->onArmSync(myo, time, + static_cast(libmyo_event_get_arm(event)), + static_cast(libmyo_event_get_x_direction(event)), + libmyo_event_get_rotation_on_arm(event), + static_cast(libmyo_event_get_warmup_state(event))); + break; + case libmyo_event_arm_unsynced: + listener->onArmUnsync(myo, time); + break; + case libmyo_event_unlocked: + listener->onUnlock(myo, time); + break; + case libmyo_event_locked: + listener->onLock(myo, time); + break; + case libmyo_event_orientation: + listener->onOrientationData(myo, time, + Quaternion(libmyo_event_get_orientation(event, libmyo_orientation_x), + libmyo_event_get_orientation(event, libmyo_orientation_y), + libmyo_event_get_orientation(event, libmyo_orientation_z), + libmyo_event_get_orientation(event, libmyo_orientation_w))); + listener->onAccelerometerData(myo, time, + Vector3(libmyo_event_get_accelerometer(event, 0), + libmyo_event_get_accelerometer(event, 1), + libmyo_event_get_accelerometer(event, 2))); + + listener->onGyroscopeData(myo, time, + Vector3(libmyo_event_get_gyroscope(event, 0), + libmyo_event_get_gyroscope(event, 1), + libmyo_event_get_gyroscope(event, 2))); + + break; + case libmyo_event_pose: + listener->onPose(myo, time, Pose(static_cast(libmyo_event_get_pose(event)))); + break; + case libmyo_event_rssi: + listener->onRssi(myo, time, libmyo_event_get_rssi(event)); + break; + case libmyo_event_battery_level: + listener->onBatteryLevelReceived(myo, time, libmyo_event_get_battery_level(event)); + break; + case libmyo_event_emg: { + int8_t emg[] = { libmyo_event_get_emg(event, 0), + libmyo_event_get_emg(event, 1), + libmyo_event_get_emg(event, 2), + libmyo_event_get_emg(event, 3), + libmyo_event_get_emg(event, 4), + libmyo_event_get_emg(event, 5), + libmyo_event_get_emg(event, 6), + libmyo_event_get_emg(event, 7) }; + listener->onEmgData(myo, time, emg); + break; + } + case libmyo_event_warmup_completed: { + listener->onWarmupCompleted(myo, time, static_cast(libmyo_event_get_warmup_result(event))); + break; + } + } + } +} + +inline +void Hub::run(unsigned int duration_ms) +{ + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + hub->onDeviceEvent(event); + + return libmyo_handler_continue; + } + }; + libmyo_run(_hub, duration_ms, &local::handler, this, ThrowOnError()); +} + +inline +void Hub::runOnce(unsigned int duration_ms) +{ + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + hub->onDeviceEvent(event); + + return libmyo_handler_stop; + } + }; + libmyo_run(_hub, duration_ms, &local::handler, this, ThrowOnError()); +} + +inline +libmyo_hub_t Hub::libmyoObject() +{ + return _hub; +} + +inline +Myo* Hub::lookupMyo(libmyo_myo_t opaqueMyo) const +{ + Myo* myo = 0; + for (std::vector::const_iterator I = _myos.begin(), IE = _myos.end(); I != IE; ++I) { + if ((*I)->libmyoObject() == opaqueMyo) { + myo = *I; + break; + } + } + + return myo; +} + +inline +Myo* Hub::addMyo(libmyo_myo_t opaqueMyo) +{ + Myo* myo = new Myo(opaqueMyo); + + _myos.push_back(myo); + + return myo; +} + +} // namespace myo diff --git a/other/myo.framework/Versions/A/Headers/cxx/impl/Myo_impl.hpp b/other/myo.framework/Versions/A/Headers/cxx/impl/Myo_impl.hpp new file mode 100755 index 0000000..84d8125 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/impl/Myo_impl.hpp @@ -0,0 +1,72 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#include "../Myo.hpp" +#include "../detail/ThrowOnError.hpp" + +#include + +namespace myo { + +inline +void Myo::vibrate(VibrationType type) +{ + libmyo_vibrate(_myo, static_cast(type), ThrowOnError()); +} + +inline +void Myo::requestRssi() const +{ + libmyo_request_rssi(_myo, ThrowOnError()); +} + +inline +void Myo::requestBatteryLevel() const +{ + libmyo_request_battery_level(_myo, myo::ThrowOnError()); +} + +inline +void Myo::unlock(UnlockType type) +{ + libmyo_myo_unlock(_myo, static_cast(type), ThrowOnError()); +} + +inline +void Myo::lock() +{ + libmyo_myo_lock(_myo, ThrowOnError()); +} + +inline +void Myo::notifyUserAction() +{ + libmyo_myo_notify_user_action(_myo, libmyo_user_action_single, ThrowOnError()); +} + +inline +void Myo::setStreamEmg(StreamEmgType type) +{ + libmyo_set_stream_emg(_myo, static_cast(type), ThrowOnError()); +} + +inline +libmyo_myo_t Myo::libmyoObject() const +{ + return _myo; +} + +inline +Myo::Myo(libmyo_myo_t myo) +: _myo(myo) +{ + if (!_myo) { + throw std::invalid_argument("Cannot construct Myo instance with null pointer"); + } +} + +inline +Myo::~Myo() +{ +} + +} // namespace myo diff --git a/other/myo.framework/Versions/A/Headers/cxx/impl/Pose_impl.hpp b/other/myo.framework/Versions/A/Headers/cxx/impl/Pose_impl.hpp new file mode 100755 index 0000000..7432e39 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/cxx/impl/Pose_impl.hpp @@ -0,0 +1,97 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_CXX_IMPL_POSE_IMPL_HPP +#define MYO_CXX_IMPL_POSE_IMPL_HPP + +#include "../Pose.hpp" + +#include + +namespace myo { + +inline +Pose::Pose() +: _type(unknown) +{ +} + +inline +Pose::Pose(Pose::Type type) +: _type(type) +{ +} + +inline +bool Pose::operator==(Pose other) const +{ + return _type == other._type; +} + +inline +bool Pose::operator!=(Pose other) const +{ + return !(*this == other); +} + +inline +Pose::Type Pose::type() const +{ + return _type; +} + +inline +bool operator==(Pose pose, Pose::Type type) +{ + return pose.type() == type; +} + +inline +bool operator==(Pose::Type type, Pose pose) +{ + return pose == type; +} + +inline +bool operator!=(Pose pose, Pose::Type type) +{ + return !(pose == type); +} + +inline +bool operator!=(Pose::Type type, Pose pose) +{ + return !(type == pose); +} + +inline +std::string Pose::toString() const +{ + switch (type()) { + case Pose::rest: + return "rest"; + case Pose::fist: + return "fist"; + case Pose::waveIn: + return "waveIn"; + case Pose::waveOut: + return "waveOut"; + case Pose::fingersSpread: + return "fingersSpread"; + case Pose::doubleTap: + return "doubleTap"; + case Pose::unknown: + return "unknown"; + } + + return ""; +} + +inline +std::ostream& operator<<(std::ostream& out, const Pose& pose) +{ + return out << pose.toString(); +} + +} // namespace myo + +#endif // MYO_CXX_IMPL_POSE_IMPL_HPP diff --git a/other/myo.framework/Versions/A/Headers/libmyo.h b/other/myo.framework/Versions/A/Headers/libmyo.h new file mode 100755 index 0000000..29a59f6 --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/libmyo.h @@ -0,0 +1,425 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_LIBMYO_H +#define MYO_LIBMYO_H + +#include + +#include "libmyo/detail/visibility.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// @file libmyo.h +/// libmyo C API declarations. + +typedef void* libmyo_hub_t; + +/// \defgroup errors Error Handling +/// @{ + +/// Function result codes. +/// All libmyo functions that can fail return a value of this type. +typedef enum { + libmyo_success, + libmyo_error, + libmyo_error_invalid_argument, + libmyo_error_runtime +} libmyo_result_t; + +/// Opaque handle to detailed error information. +typedef void* libmyo_error_details_t; + +/// Return a null-terminated string with a detailed error message. +LIBMYO_EXPORT +const char* libmyo_error_cstring(libmyo_error_details_t); + +/// Returns the kind of error that occurred. +LIBMYO_EXPORT +libmyo_result_t libmyo_error_kind(libmyo_error_details_t); + +/// Free the resources allocated by an error object. +LIBMYO_EXPORT +void libmyo_free_error_details(libmyo_error_details_t); + +/// @} + +/// \defgroup libmyo_string Strings +/// @{ + +// Opaque string. +typedef void* libmyo_string_t; + +// Return a null-terminated string from the opaque string. +LIBMYO_EXPORT +const char* libmyo_string_c_str(libmyo_string_t); + +// Free the resources allocated by the string object. +LIBMYO_EXPORT +void libmyo_string_free(libmyo_string_t); + +/// @} + +/// \defgroup libmyo_direct_mac_addresses MAC address utilities +/// @{ + +/// Retrieve the string representation of a MAC address in hex. +/// Returns a string in the format of 00-00-00-00-00-00. +LIBMYO_EXPORT +libmyo_string_t libmyo_mac_address_to_string(uint64_t); + +/// Retrieve the MAC address from a null-terminated string in the format of 00-00-00-00-00-00. +/// Returns 0 if the string does not match the format. +LIBMYO_EXPORT +uint64_t libmyo_string_to_mac_address(const char*); + +/// @} + +/// @defgroup libmyo_hub Hub instance +/// @{ + +/// Initialize a connection to the hub. +/// \a application_identifier must follow a reverse domain name format (ex. com.domainname.appname). Application +/// identifiers can be formed from the set of alphanumeric ASCII characters (a-z, A-Z, 0-9). The hyphen (-) and +/// underscore (_) characters are permitted if they are not adjacent to a period (.) character (i.e. not at the start or +/// end of each segment), but are not permitted in the top-level domain. Application identifiers must have three or more +/// segments. For example, if a company's domain is example.com and the application is named hello-world, one could use +/// "com.example.hello-world" as a valid application identifier. \a application_identifier can be NULL or empty. +/// @returns libmyo_success if the connection is successfully established, otherwise: +/// - libmyo_error_runtime if a connection could not be established +/// - libmyo_error_invalid_argument if \a out_hub is NULL +/// - libmyo_error_invalid_argument if \a application_identifier is longer than 255 characters +/// - libmyo_error_invalid_argument if \a application_identifier is not in the proper reverse domain name format +LIBMYO_EXPORT +libmyo_result_t libmyo_init_hub(libmyo_hub_t* out_hub, const char* application_identifier, + libmyo_error_details_t* out_error); + +/// Free the resources allocated to a hub. +/// @returns libmyo_success if shutdown is successful, otherwise: +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error if \a hub is not a valid hub +LIBMYO_EXPORT +libmyo_result_t libmyo_shutdown_hub(libmyo_hub_t hub, libmyo_error_details_t* out_error); + +// Locking policies. +typedef enum { + libmyo_locking_policy_none, ///< Pose events are always sent. + libmyo_locking_policy_standard ///< Pose events are not sent while a Myo is locked. +} libmyo_locking_policy_t; + +/// Set the locking policy for Myos connected to the hub. +/// @returns libmyo_success if the locking policy is successfully set, otherwise +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error if \a hub is not a valid hub +LIBMYO_EXPORT +libmyo_result_t libmyo_set_locking_policy(libmyo_hub_t hub, libmyo_locking_policy_t locking_policy, + libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_myo Myo instances +/// @{ + +/// Opaque type corresponding to a known Myo device. +typedef void* libmyo_myo_t; + +/// Types of vibration +typedef enum { + libmyo_vibration_short, + libmyo_vibration_medium, + libmyo_vibration_long +} libmyo_vibration_type_t; + +/// Retrieve the MAC address of a Myo. +/// The MAC address is unique to the physical Myo, and is a 48-bit number. +LIBMYO_EXPORT +uint64_t libmyo_get_mac_address(libmyo_myo_t myo); + +/// Vibrate the given myo. +/// Can be called when a Myo is paired. +/// @returns libmyo_success if the Myo successfully vibrated, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_vibrate(libmyo_myo_t myo, libmyo_vibration_type_t type, libmyo_error_details_t* out_error); + +/// Request the RSSI for a given myo. +/// Can be called when a Myo is paired. A libmyo_event_rssi event will likely be generated with the value of the RSSI. +/// @returns libmyo_success if the Myo successfully got the RSSI, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_request_rssi(libmyo_myo_t myo, libmyo_error_details_t* out_error); + + +/// Request the battery level for a given Myo. +/// A libmyo_event_battery_level event will be generated with the value of the battery level. +/// @returns libmyo_success if the Myo successfully requested the battery level, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_request_battery_level(libmyo_myo_t myo_opq, libmyo_error_details_t* out_error); + +/// EMG streaming modes. +typedef enum { + libmyo_stream_emg_disabled, ///< Do not send EMG data. + libmyo_stream_emg_enabled ///< Send EMG data. +} libmyo_stream_emg_t; + +/// Set whether or not to stream EMG data for a given myo. +/// Can be called when a Myo is paired. +/// @returns libmyo_success if the EMG mode was set successfully, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_set_stream_emg(libmyo_myo_t myo, libmyo_stream_emg_t emg, libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_poses Pose recognition. +/// @{ + +/// Supported poses. +typedef enum { + libmyo_pose_rest = 0, ///< Rest pose. + libmyo_pose_fist = 1, ///< User is making a fist. + libmyo_pose_wave_in = 2, ///< User has an open palm rotated towards the posterior of their wrist. + libmyo_pose_wave_out = 3, ///< User has an open palm rotated towards the anterior of their wrist. + libmyo_pose_fingers_spread = 4, ///< User has an open palm with their fingers spread away from each other. + libmyo_pose_double_tap = 5, ///< User tapped their thumb and middle finger together twice in succession. + + libmyo_num_poses, ///< Number of poses supported; not a valid pose. + + libmyo_pose_unknown = 0xffff ///< Unknown pose. +} libmyo_pose_t; + +/// @} + +/// @defgroup libmyo_locking Myo locking mechanism + +/// Valid unlock types. +typedef enum { + libmyo_unlock_timed = 0, ///< Unlock for a fixed period of time. + libmyo_unlock_hold = 1, ///< Unlock until explicitly told to re-lock. +} libmyo_unlock_type_t; + +/// Unlock the given Myo. +/// Can be called when a Myo is paired. A libmyo_event_unlocked event will be generated if the Myo was locked. +/// @returns libmyo_success if the Myo was successfully unlocked, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_unlock(libmyo_myo_t myo, libmyo_unlock_type_t type, libmyo_error_details_t* out_error); + +/// Lock the given Myo immediately. +/// Can be called when a Myo is paired. A libmyo_event_locked event will be generated if the Myo was unlocked. +/// @returns libmyo_success if the Myo was successfully locked, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_lock(libmyo_myo_t myo, libmyo_error_details_t* out_error); + +/// User action types. +typedef enum { + libmyo_user_action_single = 0, ///< User did a single, discrete action, such as pausing a video. +} libmyo_user_action_type_t; + +/// Notify the given Myo that a user action was recognized. +/// Can be called when a Myo is paired. Will cause Myo to vibrate. +/// @returns libmyo_success if the Myo was successfully notified, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_notify_user_action(libmyo_myo_t myo, libmyo_user_action_type_t type, + libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_events Event Handling +/// @{ + +/// Types of events. +typedef enum { + libmyo_event_paired, ///< Successfully paired with a Myo. + libmyo_event_unpaired, ///< Successfully unpaired from a Myo. + libmyo_event_connected, ///< A Myo has successfully connected. + libmyo_event_disconnected, ///< A Myo has been disconnected. + libmyo_event_arm_synced, ///< A Myo has recognized that the sync gesture has been successfully performed. + libmyo_event_arm_unsynced, ///< A Myo has been moved or removed from the arm. + libmyo_event_orientation, ///< Orientation data has been received. + libmyo_event_pose, ///< A change in pose has been detected. @see libmyo_pose_t. + libmyo_event_rssi, ///< An RSSI value has been received. + libmyo_event_unlocked, ///< A Myo has become unlocked. + libmyo_event_locked, ///< A Myo has become locked. + libmyo_event_emg, ///< EMG data has been received. + libmyo_event_battery_level, ///< A battery level value has been received. + libmyo_event_warmup_completed, ///< The warmup period has completed. +} libmyo_event_type_t; + +/// Information about an event. +typedef const void* libmyo_event_t; + +/// Retrieve the type of an event. +LIBMYO_EXPORT +uint32_t libmyo_event_get_type(libmyo_event_t event); + +/// Retrieve the timestamp of an event. +/// @see libmyo_now() for details on timestamps. +LIBMYO_EXPORT +uint64_t libmyo_event_get_timestamp(libmyo_event_t event); + +/// Retrieve the Myo associated with an event. +LIBMYO_EXPORT +libmyo_myo_t libmyo_event_get_myo(libmyo_event_t event); + +/// Retrieve the MAC address of the myo associated with an event. +LIBMYO_EXPORT +uint64_t libmyo_event_get_mac_address(libmyo_event_t event_opq); + +/// Retrieve the name of the myo associated with an event. +/// Caller must free the returned string. @see libmyo_string functions. +LIBMYO_EXPORT +libmyo_string_t libmyo_event_get_myo_name(libmyo_event_t event); + +/// Components of version. +typedef enum { + libmyo_version_major, ///< Major version. + libmyo_version_minor, ///< Minor version. + libmyo_version_patch, ///< Patch version. + libmyo_version_hardware_rev, ///< Hardware revision. +} libmyo_version_component_t; + +/// Hardware revisions. +typedef enum { + libmyo_hardware_rev_c = 1, ///< Alpha units + libmyo_hardware_rev_d = 2, ///< Consumer units +} libmyo_hardware_rev_t; + +/// Retrieve the Myo armband's firmware version from this event. +/// Valid for libmyo_event_paired and libmyo_event_connected events. +LIBMYO_EXPORT +unsigned int libmyo_event_get_firmware_version(libmyo_event_t event, libmyo_version_component_t); + +/// Enumeration identifying a right arm or left arm. @see libmyo_event_get_arm(). +typedef enum { + libmyo_arm_right, ///< Myo is on the right arm. + libmyo_arm_left, ///< Myo is on the left arm. + libmyo_arm_unknown, ///< Unknown arm. +} libmyo_arm_t; + +/// Retrieve the arm associated with an event. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_arm_t libmyo_event_get_arm(libmyo_event_t event); + +/// Possible directions for Myo's +x axis relative to a user's arm. +typedef enum { + libmyo_x_direction_toward_wrist, ///< Myo's +x axis is pointing toward the user's wrist. + libmyo_x_direction_toward_elbow, ///< Myo's +x axis is pointing toward the user's elbow. + libmyo_x_direction_unknown, ///< Unknown +x axis direction. +} libmyo_x_direction_t; + +/// Retrieve the x-direction associated with an event. +/// The x-direction specifies which way Myo's +x axis is pointing relative to the user's arm. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_x_direction_t libmyo_event_get_x_direction(libmyo_event_t event); + +/// Possible warmup states for Myo. +typedef enum { + libmyo_warmup_state_unknown = 0, ///< Unknown warm up state. + libmyo_warmup_state_cold = 1, ///< Myo needs to warm up. + libmyo_warmup_state_warm = 2, ///< Myo is already in a warmed up state. +} libmyo_warmup_state_t; + +/// Retrieve the warmup state of the Myo associated with an event. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_warmup_state_t libmyo_event_get_warmup_state(libmyo_event_t event); + +/// Possible warmup results for Myo. +typedef enum { + libmyo_warmup_result_unknown = 0, ///< Unknown warm up result. + libmyo_warmup_result_success = 1, ///< The warm up period has completed successfully. + libmyo_warmup_result_failed_timeout = 2, ///< The warm up period timed out. +} libmyo_warmup_result_t; + +/// Retrieve the warmup result of the Myo associated with an event. +/// Valid for libmyo_event_warmup_completed events only. +LIBMYO_EXPORT +libmyo_warmup_result_t libmyo_event_get_warmup_result(libmyo_event_t event); + +/// Retrieve the estimated rotation of Myo on the user's arm after a sync. +/// The values specifies the rotation of the myo on the arm (0 - logo facing down, pi - logo facing up) +/// Only supported by FW 1.3.x and above (older firmware will always report 0 for the rotation) +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +float libmyo_event_get_rotation_on_arm(libmyo_event_t event); + +/// Index into orientation data, which is provided as a quaternion. +/// Orientation data is returned as a unit quaternion of floats, represented as `w + x * i + y * j + z * k`. +typedef enum { + libmyo_orientation_x = 0, ///< First component of the quaternion's vector part + libmyo_orientation_y = 1, ///< Second component of the quaternion's vector part + libmyo_orientation_z = 2, ///< Third component of the quaternion's vector part + libmyo_orientation_w = 3, ///< Scalar component of the quaternion. +} libmyo_orientation_index; + +/// Retrieve orientation data associated with an event. +/// Valid for libmyo_event_orientation events only. +/// @see libmyo_orientation_index +LIBMYO_EXPORT +float libmyo_event_get_orientation(libmyo_event_t event, libmyo_orientation_index index); + +/// Retrieve raw accelerometer data associated with an event in units of g. +/// Valid for libmyo_event_orientation events only. +/// Requires `index < 3`. +LIBMYO_EXPORT +float libmyo_event_get_accelerometer(libmyo_event_t event, unsigned int index); + +/// Retrieve raw gyroscope data associated with an event in units of deg/s. +/// Valid for libmyo_event_orientation events only. +/// Requires `index < 3`. +LIBMYO_EXPORT +float libmyo_event_get_gyroscope(libmyo_event_t event, unsigned int index); + +/// Retrieve the pose associated with an event. +/// Valid for libmyo_event_pose events only. +LIBMYO_EXPORT +libmyo_pose_t libmyo_event_get_pose(libmyo_event_t event); + +/// Retreive the RSSI associated with an event. +/// Valid for libmyo_event_rssi events only. +LIBMYO_EXPORT +int8_t libmyo_event_get_rssi(libmyo_event_t event); + +/// Retrieve the battery level of the Myo armband associated with an event. +/// Only valid for libmyo_event_battery_level event. +LIBMYO_EXPORT +uint8_t libmyo_event_get_battery_level(libmyo_event_t event); + +/// Retrieve an EMG data point associated with an event. +/// Valid for libmyo_event_emg events only. +/// @a sensor must be smaller than 8. +LIBMYO_EXPORT +int8_t libmyo_event_get_emg(libmyo_event_t event, unsigned int sensor); + +/// Return type for event handlers. +typedef enum { + libmyo_handler_continue, ///< Continue processing events + libmyo_handler_stop, ///< Stop processing events +} libmyo_handler_result_t; + +/// Callback function type to handle events as they occur from libmyo_run(). +typedef libmyo_handler_result_t (*libmyo_handler_t)(void* user_data, libmyo_event_t event); + +/// Process events and call the provided callback as they occur. +/// Runs for up to approximately \a duration_ms milliseconds or until a called handler returns libmyo_handler_stop. +/// @returns libmyo_success after a successful run, otherwise +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error_invalid_argument if \a handler is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_run(libmyo_hub_t hub, unsigned int duration_ms, libmyo_handler_t handler, void* user_data, + libmyo_error_details_t* out_error); + +/// @} + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // MYO_LIBMYO_H diff --git a/other/myo.framework/Versions/A/Headers/libmyo/detail/visibility.h b/other/myo.framework/Versions/A/Headers/libmyo/detail/visibility.h new file mode 100755 index 0000000..3a23e6a --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/libmyo/detail/visibility.h @@ -0,0 +1,32 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_LIBMYO_DETAIL_VISIBILITY_H +#define MYO_LIBMYO_DETAIL_VISIBILITY_H + +#if defined(_WIN32) || defined(__CYGWIN__) + #ifdef myo_EXPORTS + #ifdef __GNUC__ + #define LIBMYO_EXPORT __attribute__ ((dllexport)) + #else + #define LIBMYO_EXPORT __declspec(dllexport) + #endif + #else + #ifdef LIBMYO_STATIC_BUILD + #define LIBMYO_EXPORT + #else + #ifdef __GNUC__ + #define LIBMYO_EXPORT __attribute__ ((dllimport)) + #else + #define LIBMYO_EXPORT __declspec(dllimport) + #endif + #endif + #endif +#else + #if __GNUC__ >= 4 + #define LIBMYO_EXPORT __attribute__ ((visibility ("default"))) + #else + #define LIBMYO_EXPORT + #endif +#endif + +#endif // MYO_LIBMYO_DETAIL_VISIBILITY_H diff --git a/other/myo.framework/Versions/A/Headers/myo.hpp b/other/myo.framework/Versions/A/Headers/myo.hpp new file mode 100755 index 0000000..5ea17fb --- /dev/null +++ b/other/myo.framework/Versions/A/Headers/myo.hpp @@ -0,0 +1,13 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +/// The namespace in which all of the %Myo C++ bindings are contained. +namespace myo {} + +#include "cxx/DeviceListener.hpp" +#include "cxx/Hub.hpp" +#include "cxx/Myo.hpp" +#include "cxx/Pose.hpp" +#include "cxx/Quaternion.hpp" +#include "cxx/Vector3.hpp" diff --git a/other/myo.framework/Versions/A/Resources/Info.plist b/other/myo.framework/Versions/A/Resources/Info.plist new file mode 100755 index 0000000..aeec5cc --- /dev/null +++ b/other/myo.framework/Versions/A/Resources/Info.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + myo + CFBundleIconFile + + CFBundleIdentifier + + CFBundleInfoDictionaryVersion + 6.0 + CFBundlePackageType + FMWK + CFBundleSignature + ???? + CFBundleVersion + + CFBundleShortVersionString + + CSResourcesFileMapped + + + diff --git a/other/myo.framework/Versions/A/_CodeSignature/CodeResources b/other/myo.framework/Versions/A/_CodeSignature/CodeResources new file mode 100755 index 0000000..94014f5 --- /dev/null +++ b/other/myo.framework/Versions/A/_CodeSignature/CodeResources @@ -0,0 +1,167 @@ + + + + + files + + Resources/Info.plist + + tUgLZV94WtJ7c7dl1ZQDEnyfe2U= + + + files2 + + Headers/cxx/DeviceListener.hpp + + 5frQIrDj5Rod49qbH8F/ODv03cg= + + Headers/cxx/Hub.hpp + + i2GwmXkJaAf8ZK1boAQLVFA9FuQ= + + Headers/cxx/Myo.hpp + + zkwa8CxGu7CxuY09ncg4cs2C0Ik= + + Headers/cxx/Pose.hpp + + bV/b65asnTpOQVVUseBE2Jks2yY= + + Headers/cxx/Quaternion.hpp + + bvsi/ZwGqVs0ZiHbWPUtsWlsK8k= + + Headers/cxx/Vector3.hpp + + OQUYhjK6FE/MwW8eyy24OtbHO4I= + + Headers/cxx/detail/ThrowOnError.hpp + + ZG7+E/cEH4UadH/3StifiGVjRxE= + + Headers/cxx/impl/Hub_impl.hpp + + jPk/hrtJnF4CumxpYjsOPpHH8PM= + + Headers/cxx/impl/Myo_impl.hpp + + 1IleanLjzRkjPeQaDU5tHCnz3+k= + + Headers/cxx/impl/Pose_impl.hpp + + dimtyDcx8DWcpkDi1creWJADmRA= + + Headers/libmyo.h + + 0nJ1nA0iCBjWxuXv2VZ2vRHjXnY= + + Headers/libmyo/detail/visibility.h + + dPUWLcemRGRDAJVc1Gonqqzo2K0= + + Headers/myo.hpp + + JeFdPeQ4BqtfHJyJxRiXrDHj6xw= + + Resources/Info.plist + + tUgLZV94WtJ7c7dl1ZQDEnyfe2U= + + + rules + + ^Resources/ + + ^Resources/.*\.lproj/ + + optional + + weight + 1000 + + ^Resources/.*\.lproj/locversion.plist$ + + omit + + weight + 1100 + + ^version.plist$ + + + rules2 + + .*\.dSYM($|/) + + weight + 11 + + ^(.*/)?\.DS_Store$ + + omit + + weight + 2000 + + ^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/ + + nested + + weight + 10 + + ^.* + + ^Info\.plist$ + + omit + + weight + 20 + + ^PkgInfo$ + + omit + + weight + 20 + + ^Resources/ + + weight + 20 + + ^Resources/.*\.lproj/ + + optional + + weight + 1000 + + ^Resources/.*\.lproj/locversion.plist$ + + omit + + weight + 1100 + + ^[^/]+$ + + nested + + weight + 10 + + ^embedded\.provisionprofile$ + + weight + 20 + + ^version\.plist$ + + weight + 20 + + + + diff --git a/other/myo.framework/Versions/A/myo b/other/myo.framework/Versions/A/myo new file mode 100755 index 0000000..ba6e3e9 Binary files /dev/null and b/other/myo.framework/Versions/A/myo differ diff --git a/other/myo.framework/Versions/Current/Headers/cxx/DeviceListener.hpp b/other/myo.framework/Versions/Current/Headers/cxx/DeviceListener.hpp new file mode 100755 index 0000000..816cab3 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/DeviceListener.hpp @@ -0,0 +1,197 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include "Pose.hpp" + +namespace myo { + +class Myo; +template +class Quaternion; +template +class Vector3; + +/// Enumeration identifying a right arm or left arm. +enum Arm { + armLeft = libmyo_arm_left, + armRight = libmyo_arm_right, + armUnknown = libmyo_arm_unknown +}; + +/// Possible directions for Myo's +x axis relative to a user's arm. +enum XDirection { + xDirectionTowardWrist = libmyo_x_direction_toward_wrist, + xDirectionTowardElbow = libmyo_x_direction_toward_elbow, + xDirectionUnknown = libmyo_x_direction_unknown +}; + +/// Possible warmup states for a Myo. +enum WarmupState { + warmupStateUnknown = libmyo_warmup_state_unknown, + warmupStateCold = libmyo_warmup_state_cold, + warmupStateWarm = libmyo_warmup_state_warm, +}; + +/// Possible warmup results for a Myo. +enum WarmupResult { + warmupResultUnknown = libmyo_warmup_result_unknown, + warmupResultSuccess = libmyo_warmup_result_success, + warmupResultFailedTimeout = libmyo_warmup_result_failed_timeout, +}; + +/// Firmware version of Myo. +struct FirmwareVersion { + unsigned int firmwareVersionMajor; ///< Myo's major version must match the required major version. + unsigned int firmwareVersionMinor; ///< Myo's minor version must match the required minor version. + unsigned int firmwareVersionPatch; ///< Myo's patch version must greater or equal to the required patch version. + unsigned int firmwareVersionHardwareRev; ///< Myo's hardware revision; not used to detect firmware version mismatch. +}; + +/// A DeviceListener receives events about a Myo. +/// @see Hub::addListener() +class DeviceListener { +public: + virtual ~DeviceListener() {} + + /// Called when a Myo has been paired. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param firmwareVersion The firmware version of \a myo. + virtual void onPair(Myo* myo, uint64_t timestamp, FirmwareVersion firmwareVersion) {} + + /// Called when a Myo has been unpaired. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onUnpair(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo has been connected. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param firmwareVersion The firmware version of \a myo. + virtual void onConnect(Myo* myo, uint64_t timestamp, FirmwareVersion firmwareVersion) {} + + /// Called when a paired Myo has been disconnected. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onDisconnect(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo recognizes that it is on an arm. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param arm The identified Arm of \a myo. + /// @param xDirection The identified XDirection of \a myo. + /// @param rotation The estimated rotation of Myo on the user's arm after a sync. + /// @param warmupState The warmup state of \a myo. If \a warmupState is equal to WarmupState::warmupStateCold, + /// onWarmupCompleted() will be called when the warmup period has completed. + virtual void onArmSync(Myo* myo, uint64_t timestamp, Arm arm, XDirection xDirection, float rotation, + WarmupState warmupState) {} + + /// Called when a paired Myo is moved or removed from the arm. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onArmUnsync(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo becomes unlocked. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onUnlock(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo becomes locked. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + virtual void onLock(Myo* myo, uint64_t timestamp) {} + + /// Called when a paired Myo has provided a new pose. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param pose The identified Pose of \a myo. + virtual void onPose(Myo* myo, uint64_t timestamp, Pose pose) {} + + /// Called when a paired Myo has provided new orientation data. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param rotation The orientation data of \a myo, as a Quaternion. + virtual void onOrientationData(Myo* myo, uint64_t timestamp, const Quaternion& rotation) {} + + /// Called when a paired Myo has provided new accelerometer data in units of g. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param accel The accelerometer data of \a myo, in units of g. + virtual void onAccelerometerData(Myo* myo, uint64_t timestamp, const Vector3& accel) {} + + /// Called when a paired Myo has provided new gyroscope data in units of deg/s. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param gyro The gyroscope data of \a myo, in units of deg/s. + virtual void onGyroscopeData(Myo* myo, uint64_t timestamp, const Vector3& gyro) {} + + /// Called when a paired Myo has provided a new RSSI value. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param rssi The RSSI (received signal strength indication) of \a myo. + /// @see Myo::requestRssi() to request an RSSI value from the Myo. + virtual void onRssi(Myo* myo, uint64_t timestamp, int8_t rssi) {} + + /// Called when a paired Myo receives an battery level update. + /// Updates occur when the battery level changes and when the battery level is explicitly requested. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param level battery level reported by the myo the value is a number from 0 to 100 representing the percentage + /// of battery life remaining. + virtual void onBatteryLevelReceived(myo::Myo* myo, uint64_t timestamp, uint8_t level) {} + + /// Called when a paired Myo has provided new EMG data. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param emg An array of 8 elements, each corresponding to one sensor. + virtual void onEmgData(myo::Myo* myo, uint64_t timestamp, const int8_t* emg) {} + + /// Called when the warmup period for a Myo has completed. + /// @param myo The Myo for this event. + /// @param timestamp The timestamp of when the event is received by the SDK. Timestamps are 64 bit unsigned + /// integers that correspond to a number of microseconds since some (unspecified) period in time. Timestamps + /// are monotonically non-decreasing. + /// @param warmupResult The warmup result of \a myo. + virtual void onWarmupCompleted(myo::Myo* myo, uint64_t timestamp, WarmupResult warmupResult) {} + + /// @cond LIBMYO_INTERNALS + + virtual void onOpaqueEvent(libmyo_event_t event) {} + + /// @endcond +}; + +} // namespace myo diff --git a/other/myo.framework/Versions/Current/Headers/cxx/Hub.hpp b/other/myo.framework/Versions/Current/Headers/cxx/Hub.hpp new file mode 100755 index 0000000..1d4a3e0 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/Hub.hpp @@ -0,0 +1,91 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include + +namespace myo { + +class Myo; +class DeviceListener; + +/// @brief A Hub provides access to one or more Myo instances. +class Hub { +public: + /// Construct a hub. + /// \a applicationIdentifier must follow a reverse domain name format (ex. com.domainname.appname). Application + /// identifiers can be formed from the set of alphanumeric ASCII characters (a-z, A-Z, 0-9). The hyphen (-) and + /// underscore (_) characters are permitted if they are not adjacent to a period (.) character (i.e. not at the + /// start or end of each segment), but are not permitted in the top-level domain. Application identifiers must have + /// three or more segments. For example, if a company's domain is example.com and the application is named + /// hello-world, one could use "com.example.hello-world" as a valid application identifier. \a applicationIdentifier + /// can be an empty string. + /// Throws an exception of type std::invalid_argument if \a applicationIdentifier is not in the proper reverse + /// domain name format or is longer than 255 characters. + /// Throws an exception of type std::runtime_error if the hub initialization failed for some reason, typically + /// because Myo Connect is not running and a connection can thus not be established. + Hub(const std::string& applicationIdentifier = ""); + + /// Deallocate any resources associated with a Hub. + /// This will cause all Myo instances retrieved from this Hub to become invalid. + ~Hub(); + + /// Wait for a Myo to become paired, or time out after \a timeout_ms milliseconds if provided. + /// If \a timeout_ms is zero, this function blocks until a Myo is found. + /// This function must not be called concurrently with run() or runOnce(). + Myo* waitForMyo(unsigned int milliseconds = 0); + + /// Register a listener to be called when device events occur. + void addListener(DeviceListener* listener); + + /// Remove a previously registered listener. + void removeListener(DeviceListener* listener); + + /// Locking policies supported by Myo. + enum LockingPolicy { + lockingPolicyNone = libmyo_locking_policy_none, + lockingPolicyStandard = libmyo_locking_policy_standard + }; + + /// Set the locking policy for Myos connected to the Hub. + void setLockingPolicy(LockingPolicy lockingPolicy); + + /// Run the event loop for the specified duration (in milliseconds). + void run(unsigned int duration_ms); + + /// Run the event loop until a single event occurs, or the specified duration (in milliseconds) has elapsed. + void runOnce(unsigned int duration_ms); + + /// @cond MYO_INTERNALS + + /// Return the internal libmyo object corresponding to this hub. + libmyo_hub_t libmyoObject(); + +protected: + void onDeviceEvent(libmyo_event_t event); + + Myo* lookupMyo(libmyo_myo_t opaqueMyo) const; + + Myo* addMyo(libmyo_myo_t opaqueMyo); + + libmyo_hub_t _hub; + std::vector _myos; + std::vector _listeners; + + /// @endcond + +private: + // Not implemented + Hub(const Hub&); + Hub& operator=(const Hub&); +}; + +/// @example hello-myo.cpp +/// @example multiple-myos.cpp +/// @example emg-data-sample.cpp + +} // namespace myo + +#include "impl/Hub_impl.hpp" diff --git a/other/myo.framework/Versions/Current/Headers/cxx/Myo.hpp b/other/myo.framework/Versions/Current/Headers/cxx/Myo.hpp new file mode 100755 index 0000000..c030e09 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/Myo.hpp @@ -0,0 +1,83 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +namespace myo { + +/// Represents a Myo device with a specific MAC address. +/// This class can not be instantiated directly; instead, use Hub to get access to a Myo. +/// There is only one Myo instance corresponding to each device; thus, if the addresses of two Myo instances compare +/// equal, they refer to the same device. +class Myo { +public: + /// Types of vibration supported by the Myo. + enum VibrationType { + vibrationShort = libmyo_vibration_short, + vibrationMedium = libmyo_vibration_medium, + vibrationLong = libmyo_vibration_long + }; + + /// Vibrate the Myo. + void vibrate(VibrationType type); + + /// Request the RSSI of the Myo. An onRssi event will likely be generated with the value of the RSSI. + /// @see DeviceListener::onRssi() + void requestRssi() const; + + /// Request the battery level of the Myo. An onBatteryLevelReceived event will be generated with the value. + /// @see DeviceListener::onBatteryLevelReceived(). + void requestBatteryLevel() const; + + /// Unlock types supported by Myo. + enum UnlockType { + unlockTimed = libmyo_unlock_timed, + unlockHold = libmyo_unlock_hold + }; + + /// Unlock the Myo. + /// Myo will remain unlocked for a short amount of time, after which it will automatically lock again. + /// If Myo was locked, an onUnlock event will be generated. + void unlock(UnlockType type); + + /// Force the Myo to lock immediately. + /// If Myo was unlocked, an onLock event will be generated. + void lock(); + + /// Notify the Myo that a user action was recognized. + /// Will cause Myo to vibrate. + void notifyUserAction(); + + /// Valid EMG streaming modes for a Myo. + enum StreamEmgType { + streamEmgDisabled = libmyo_stream_emg_disabled, + streamEmgEnabled = libmyo_stream_emg_enabled + }; + + /// Sets the EMG streaming mode for a Myo. + void setStreamEmg(StreamEmgType type); + + /// @cond MYO_INTERNALS + + /// Return the internal libmyo object corresponding to this device. + libmyo_myo_t libmyoObject() const; + + /// @endcond + +private: + Myo(libmyo_myo_t myo); + ~Myo(); + + libmyo_myo_t _myo; + + // Not implemented. + Myo(const Myo&); + Myo& operator=(const Myo&); + + friend class Hub; +}; + +} // namespace myo + +#include "impl/Myo_impl.hpp" diff --git a/other/myo.framework/Versions/Current/Headers/cxx/Pose.hpp b/other/myo.framework/Versions/Current/Headers/cxx/Pose.hpp new file mode 100755 index 0000000..8d668b4 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/Pose.hpp @@ -0,0 +1,70 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include +#include + +#include + +namespace myo { + +/// A pose represents a detected configuration of the user's hand. +class Pose { +public: + /// Types of poses supported by the SDK. + enum Type { + rest = libmyo_pose_rest, + fist = libmyo_pose_fist, + waveIn = libmyo_pose_wave_in, + waveOut = libmyo_pose_wave_out, + fingersSpread = libmyo_pose_fingers_spread, + doubleTap = libmyo_pose_double_tap, + unknown = libmyo_pose_unknown + }; + + /// Construct a pose of type Pose::none. + Pose(); + + /// Construct a pose with the given type. + Pose(Type type); + + /// Returns true if and only if the two poses are of the same type. + bool operator==(Pose other) const; + + /// Equivalent to `!(*this == other)`. + bool operator!=(Pose other) const; + + /// Returns the type of this pose. + Type type() const; + + /// Return a human-readable string representation of the pose. + std::string toString() const; + +private: + Type _type; +}; + +/// @relates Pose +/// Returns true if and only if the type of pose is the same as the provided type. +bool operator==(Pose pose, Pose::Type t); + +/// @relates Pose +/// Equivalent to `pose == type`. +bool operator==(Pose::Type type, Pose pose); + +/// @relates Pose +/// Equivalent to `!(pose == type)`. +bool operator!=(Pose pose, Pose::Type type); + +/// @relates Pose +/// Equivalent to `!(type == pose)`. +bool operator!=(Pose::Type type, Pose pose); + +/// @relates Pose +/// Write the name of the provided pose to the provided output stream. +std::ostream& operator<<(std::ostream& out, const Pose& pose); + +} // namespace myo + +#include "impl/Pose_impl.hpp" diff --git a/other/myo.framework/Versions/Current/Headers/cxx/Quaternion.hpp b/other/myo.framework/Versions/Current/Headers/cxx/Quaternion.hpp new file mode 100755 index 0000000..6e56df3 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/Quaternion.hpp @@ -0,0 +1,158 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#include + +#include "Vector3.hpp" + +namespace myo { + +/// A quaternion that can be used to represent a rotation. +/// This type provides only very basic functionality to store quaternions that's sufficient to retrieve the data to +/// be placed in a full featured quaternion type. +template +class Quaternion { + public: + /// Construct a quaternion that represents zero rotation (i.e. the multiplicative identity). + Quaternion() + : _x(0) + , _y(0) + , _z(0) + , _w(1) + { + } + + /// Construct a quaternion with the provided components. + Quaternion(T x, T y, T z, T w) + : _x(x) + , _y(y) + , _z(z) + , _w(w) + { + } + + /// Set the components of this quaternion to be those of the other. + Quaternion& operator=(const Quaternion other) + { + _x = other._x; + _y = other._y; + _z = other._z; + _w = other._w; + + return *this; + } + + /// Return the x-component of this quaternion's vector. + T x() const { return _x; } + + /// Return the y-component of this quaternion's vector. + T y() const { return _y; } + + /// Return the z-component of this quaternion's vector. + T z() const { return _z; } + + /// Return the w-component (scalar) of this quaternion. + T w() const { return _w; } + + /// Return the quaternion multiplied by \a rhs. + /// Note that quaternion multiplication is not commutative. + Quaternion operator*(const Quaternion& rhs) const + { + return Quaternion( + _w * rhs._x + _x * rhs._w + _y * rhs._z - _z * rhs._y, + _w * rhs._y - _x * rhs._z + _y * rhs._w + _z * rhs._x, + _w * rhs._z + _x * rhs._y - _y * rhs._x + _z * rhs._w, + _w * rhs._w - _x * rhs._x - _y * rhs._y - _z * rhs._z + ); + } + + /// Multiply this quaternion by \a rhs. + /// Return this quaternion updated with the result. + Quaternion& operator*=(const Quaternion& rhs) + { + *this = *this * rhs; + return *this; + } + + /// Return the unit quaternion corresponding to the same rotation as this one. + Quaternion normalized() const + { + T magnitude = std::sqrt(_x * _x + _y * _y + _z * _z + _w * _w); + + return Quaternion(_x / magnitude, _y / magnitude, _z / magnitude, _w / magnitude); + } + + /// Return this quaternion's conjugate. + Quaternion conjugate() const + { + return Quaternion(-_x, -_y, -_z, _w); + } + + /// Return a quaternion that represents a right-handed rotation of \a angle radians about the given \a axis. + /// \a axis The unit vector representing the axis of rotation. + /// \a angle The angle of rotation, in radians. + static Quaternion fromAxisAngle(const myo::Vector3& axis, T angle) + { + return Quaternion(axis.x() * std::sin(angle / 2), + axis.y() * std::sin(angle / 2), + axis.z() * std::sin(angle / 2), + std::cos(angle / 2)); + } + + private: + T _x, _y, _z, _w; +}; + +/// Return a copy of this \a vec rotated by \a quat. +/// \relates myo::Quaternion +template +Vector3 rotate(const Quaternion& quat, const Vector3& vec) +{ + myo::Quaternion qvec(vec.x(), vec.y(), vec.z(), 0); + myo::Quaternion result = quat * qvec * quat.conjugate(); + return Vector3(result.x(), result.y(), result.z()); +} + +/// Return a quaternion that represents a rotation from vector \a from to \a to. +/// \relates myo::Quaternion +/// See http://stackoverflow.com/questions/1171849/finding-quaternion-representing-the-rotation-from-one-vector-to-another +/// for some explanation. +template +Quaternion rotate(const Vector3& from, const Vector3& to) +{ + Vector3 cross = from.cross(to); + + // The product of the square of magnitudes and the cosine of the angle between from and to. + T cosTheta = from.dot(to); + + // Return identity if the vectors are the same direction. + if (cosTheta >= 1) { + return Quaternion(); + } + + // The product of the square of the magnitudes + T k = std::sqrt(from.dot(from) * to.dot(to)); + + // Return identity in the degenerate case. + if (k <= 0) { + return Quaternion(); + } + + // Special handling for vectors facing opposite directions. + if (cosTheta / k <= -1) { + Vector3 xAxis(1, 0, 0); + Vector3 yAxis(0, 1, 0); + + cross = from.cross(std::abs(from.dot(xAxis)) < 1 ? xAxis : yAxis); + k = cosTheta = 0; + } + + return Quaternion( + cross.x(), + cross.y(), + cross.z(), + k + cosTheta); +} + +} // namespace myo diff --git a/other/myo.framework/Versions/Current/Headers/cxx/Vector3.hpp b/other/myo.framework/Versions/Current/Headers/cxx/Vector3.hpp new file mode 100755 index 0000000..774654b --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/Vector3.hpp @@ -0,0 +1,103 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +#define _USE_MATH_DEFINES +#include + +namespace myo { + +/// A vector of three components. +/// This type provides very basic functionality to store a three dimensional vector that's sufficient to retrieve +/// the data to be placed in a full featured vector type. A few common vector operations, such as dot product and +/// cross product, are also provided. +template +class Vector3 { + public: + /// Construct a vector of all zeroes. + Vector3() + { + _data[0] = 0; + _data[1] = 0; + _data[2] = 0; + } + + /// Construct a vector with the three provided components. + Vector3(T x, T y, T z) + { + _data[0] = x; + _data[1] = y; + _data[2] = z; + } + + /// Construct a vector with the same components as \a other. + Vector3(const Vector3& other) + { + *this = other; + } + + /// Set the components of this vector to be the same as \a other. + Vector3& operator=(const Vector3& other) + { + _data[0] = other._data[0]; + _data[1] = other._data[1]; + _data[2] = other._data[2]; + + return *this; + } + + /// Return a copy of the component of this vector at \a index, which should be 0, 1, or 2. + T operator[](unsigned int index) const + { + return _data[index]; + } + + /// Return the x-component of this vector. + T x() const { return _data[0]; } + + /// Return the y-component of this vector. + T y() const { return _data[1]; } + + /// Return the z-component of this vector. + T z() const { return _data[2]; } + + /// Return the magnitude of this vector. + T magnitude() const + { + return std::sqrt(x() * x() + y() * y() + z() * z()); + } + + /// Return a normalized copy of this vector. + Vector3 normalized() const + { + T norm = magnitude(); + return Vector3(x() / norm, y() / norm, z() / norm); + } + + /// Return the dot product of this vector and \a rhs. + T dot(const Vector3& rhs) const + { + return x() * rhs.x() + y() * rhs.y() + z() * rhs.z(); + } + + /// Return the cross product of this vector and \a rhs. + Vector3 cross(const Vector3& rhs) const + { + return Vector3( + y() * rhs.z() - z() * rhs.y(), + z() * rhs.x() - x() * rhs.z(), + x() * rhs.y() - y() * rhs.x() + ); + } + + /// Return the angle between this vector and \a rhs, in radians. + T angleTo(const Vector3& rhs) const + { + return std::acos(dot(rhs) / (magnitude() * rhs.magnitude())); + } + + private: + T _data[3]; +}; + +} // namespace myo diff --git a/other/myo.framework/Versions/Current/Headers/cxx/detail/ThrowOnError.hpp b/other/myo.framework/Versions/Current/Headers/cxx/detail/ThrowOnError.hpp new file mode 100755 index 0000000..3be0f3f --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/detail/ThrowOnError.hpp @@ -0,0 +1,70 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_CXX_DETAIL_THROWONERROR_HPP +#define MYO_CXX_DETAIL_THROWONERROR_HPP + +#include + +#include + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +#define LIBMYO_NOEXCEPT(b) +#else +#if __cplusplus >= 201103L +# define LIBMYO_NOEXCEPT(b) noexcept(b) +#else +# define LIBMYO_NOEXCEPT(b) +#endif +#endif + +namespace myo { + +class ThrowOnError { +public: + ThrowOnError() + : _error() + { + } + + ~ThrowOnError() LIBMYO_NOEXCEPT(false) + { + if (_error) + { + switch (libmyo_error_kind(_error)) { + case libmyo_error: + case libmyo_error_runtime: + { + std::runtime_error exception(libmyo_error_cstring(_error)); + libmyo_free_error_details(_error); + throw exception; + } + case libmyo_error_invalid_argument: + { + std::invalid_argument exception(libmyo_error_cstring(_error)); + libmyo_free_error_details(_error); + throw exception; + } + case libmyo_success: + { + break; + } + } + } + } + + operator libmyo_error_details_t*() + { + return &_error; + } + +private: + libmyo_error_details_t _error; + + // Not implemented + ThrowOnError(const ThrowOnError&); // = delete; + ThrowOnError& operator=(const ThrowOnError&); // = delete; +}; + +} //namespace libmyo + +#endif // MYO_CXX_DETAIL_THROWONERROR_HPP diff --git a/other/myo.framework/Versions/Current/Headers/cxx/impl/Hub_impl.hpp b/other/myo.framework/Versions/Current/Headers/cxx/impl/Hub_impl.hpp new file mode 100755 index 0000000..5e5244e --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/impl/Hub_impl.hpp @@ -0,0 +1,265 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#include "../Hub.hpp" + +#include +#include + +#include "../DeviceListener.hpp" +#include "../Myo.hpp" +#include "../Pose.hpp" +#include "../Quaternion.hpp" +#include "../Vector3.hpp" +#include "../detail/ThrowOnError.hpp" + +namespace myo { + +inline +Hub::Hub(const std::string& applicationIdentifier) +: _hub(0) +, _myos() +, _listeners() +{ + libmyo_init_hub(&_hub, applicationIdentifier.c_str(), ThrowOnError()); +} + +inline +Hub::~Hub() +{ + for (std::vector::iterator I = _myos.begin(), IE = _myos.end(); I != IE; ++I) { + delete *I; + } + libmyo_shutdown_hub(_hub, 0); +} + +inline +Myo* Hub::waitForMyo(unsigned int timeout_ms) +{ + std::size_t prevSize = _myos.size(); + + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + libmyo_myo_t opaque_myo = libmyo_event_get_myo(event); + + switch (libmyo_event_get_type(event)) { + case libmyo_event_paired: + hub->addMyo(opaque_myo); + return libmyo_handler_stop; + default: + break; + } + + return libmyo_handler_continue; + } + }; + + do { + libmyo_run(_hub, timeout_ms ? timeout_ms : 1000, &local::handler, this, ThrowOnError()); + } while (!timeout_ms && _myos.size() <= prevSize); + + if (_myos.size() <= prevSize) { + return 0; + } + + return _myos.back(); +} + +inline +void Hub::addListener(DeviceListener* listener) +{ + if (std::find(_listeners.begin(), _listeners.end(), listener) != _listeners.end()) { + // Listener was already added. + return; + } + _listeners.push_back(listener); +} + +inline +void Hub::removeListener(DeviceListener* listener) +{ + std::vector::iterator I = std::find(_listeners.begin(), _listeners.end(), listener); + if (I == _listeners.end()) { + // Don't have this listener. + return; + } + + _listeners.erase(I); +} + +inline +void Hub::setLockingPolicy(LockingPolicy lockingPolicy) +{ + libmyo_set_locking_policy(_hub, static_cast(lockingPolicy), ThrowOnError()); +} + +inline +void Hub::onDeviceEvent(libmyo_event_t event) +{ + libmyo_myo_t opaqueMyo = libmyo_event_get_myo(event); + + Myo* myo = lookupMyo(opaqueMyo); + + if (!myo && libmyo_event_get_type(event) == libmyo_event_paired) { + myo = addMyo(opaqueMyo); + } + + if (!myo) { + // Ignore events for Myos we don't know about. + return; + } + + for (std::vector::iterator I = _listeners.begin(), IE = _listeners.end(); I != IE; ++I) { + DeviceListener* listener = *I; + + listener->onOpaqueEvent(event); + + uint64_t time = libmyo_event_get_timestamp(event); + + switch (libmyo_event_get_type(event)) { + case libmyo_event_paired: { + FirmwareVersion version = {libmyo_event_get_firmware_version(event, libmyo_version_major), + libmyo_event_get_firmware_version(event, libmyo_version_minor), + libmyo_event_get_firmware_version(event, libmyo_version_patch), + libmyo_event_get_firmware_version(event, libmyo_version_hardware_rev)}; + listener->onPair(myo, time, version); + break; + } + case libmyo_event_unpaired: + listener->onUnpair(myo, time); + break; + case libmyo_event_connected: { + FirmwareVersion version = {libmyo_event_get_firmware_version(event, libmyo_version_major), + libmyo_event_get_firmware_version(event, libmyo_version_minor), + libmyo_event_get_firmware_version(event, libmyo_version_patch), + libmyo_event_get_firmware_version(event, libmyo_version_hardware_rev)}; + listener->onConnect(myo, time, version); + break; + } + case libmyo_event_disconnected: + listener->onDisconnect(myo, time); + break; + case libmyo_event_arm_synced: + listener->onArmSync(myo, time, + static_cast(libmyo_event_get_arm(event)), + static_cast(libmyo_event_get_x_direction(event)), + libmyo_event_get_rotation_on_arm(event), + static_cast(libmyo_event_get_warmup_state(event))); + break; + case libmyo_event_arm_unsynced: + listener->onArmUnsync(myo, time); + break; + case libmyo_event_unlocked: + listener->onUnlock(myo, time); + break; + case libmyo_event_locked: + listener->onLock(myo, time); + break; + case libmyo_event_orientation: + listener->onOrientationData(myo, time, + Quaternion(libmyo_event_get_orientation(event, libmyo_orientation_x), + libmyo_event_get_orientation(event, libmyo_orientation_y), + libmyo_event_get_orientation(event, libmyo_orientation_z), + libmyo_event_get_orientation(event, libmyo_orientation_w))); + listener->onAccelerometerData(myo, time, + Vector3(libmyo_event_get_accelerometer(event, 0), + libmyo_event_get_accelerometer(event, 1), + libmyo_event_get_accelerometer(event, 2))); + + listener->onGyroscopeData(myo, time, + Vector3(libmyo_event_get_gyroscope(event, 0), + libmyo_event_get_gyroscope(event, 1), + libmyo_event_get_gyroscope(event, 2))); + + break; + case libmyo_event_pose: + listener->onPose(myo, time, Pose(static_cast(libmyo_event_get_pose(event)))); + break; + case libmyo_event_rssi: + listener->onRssi(myo, time, libmyo_event_get_rssi(event)); + break; + case libmyo_event_battery_level: + listener->onBatteryLevelReceived(myo, time, libmyo_event_get_battery_level(event)); + break; + case libmyo_event_emg: { + int8_t emg[] = { libmyo_event_get_emg(event, 0), + libmyo_event_get_emg(event, 1), + libmyo_event_get_emg(event, 2), + libmyo_event_get_emg(event, 3), + libmyo_event_get_emg(event, 4), + libmyo_event_get_emg(event, 5), + libmyo_event_get_emg(event, 6), + libmyo_event_get_emg(event, 7) }; + listener->onEmgData(myo, time, emg); + break; + } + case libmyo_event_warmup_completed: { + listener->onWarmupCompleted(myo, time, static_cast(libmyo_event_get_warmup_result(event))); + break; + } + } + } +} + +inline +void Hub::run(unsigned int duration_ms) +{ + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + hub->onDeviceEvent(event); + + return libmyo_handler_continue; + } + }; + libmyo_run(_hub, duration_ms, &local::handler, this, ThrowOnError()); +} + +inline +void Hub::runOnce(unsigned int duration_ms) +{ + struct local { + static libmyo_handler_result_t handler(void* user_data, libmyo_event_t event) { + Hub* hub = static_cast(user_data); + + hub->onDeviceEvent(event); + + return libmyo_handler_stop; + } + }; + libmyo_run(_hub, duration_ms, &local::handler, this, ThrowOnError()); +} + +inline +libmyo_hub_t Hub::libmyoObject() +{ + return _hub; +} + +inline +Myo* Hub::lookupMyo(libmyo_myo_t opaqueMyo) const +{ + Myo* myo = 0; + for (std::vector::const_iterator I = _myos.begin(), IE = _myos.end(); I != IE; ++I) { + if ((*I)->libmyoObject() == opaqueMyo) { + myo = *I; + break; + } + } + + return myo; +} + +inline +Myo* Hub::addMyo(libmyo_myo_t opaqueMyo) +{ + Myo* myo = new Myo(opaqueMyo); + + _myos.push_back(myo); + + return myo; +} + +} // namespace myo diff --git a/other/myo.framework/Versions/Current/Headers/cxx/impl/Myo_impl.hpp b/other/myo.framework/Versions/Current/Headers/cxx/impl/Myo_impl.hpp new file mode 100755 index 0000000..84d8125 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/impl/Myo_impl.hpp @@ -0,0 +1,72 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#include "../Myo.hpp" +#include "../detail/ThrowOnError.hpp" + +#include + +namespace myo { + +inline +void Myo::vibrate(VibrationType type) +{ + libmyo_vibrate(_myo, static_cast(type), ThrowOnError()); +} + +inline +void Myo::requestRssi() const +{ + libmyo_request_rssi(_myo, ThrowOnError()); +} + +inline +void Myo::requestBatteryLevel() const +{ + libmyo_request_battery_level(_myo, myo::ThrowOnError()); +} + +inline +void Myo::unlock(UnlockType type) +{ + libmyo_myo_unlock(_myo, static_cast(type), ThrowOnError()); +} + +inline +void Myo::lock() +{ + libmyo_myo_lock(_myo, ThrowOnError()); +} + +inline +void Myo::notifyUserAction() +{ + libmyo_myo_notify_user_action(_myo, libmyo_user_action_single, ThrowOnError()); +} + +inline +void Myo::setStreamEmg(StreamEmgType type) +{ + libmyo_set_stream_emg(_myo, static_cast(type), ThrowOnError()); +} + +inline +libmyo_myo_t Myo::libmyoObject() const +{ + return _myo; +} + +inline +Myo::Myo(libmyo_myo_t myo) +: _myo(myo) +{ + if (!_myo) { + throw std::invalid_argument("Cannot construct Myo instance with null pointer"); + } +} + +inline +Myo::~Myo() +{ +} + +} // namespace myo diff --git a/other/myo.framework/Versions/Current/Headers/cxx/impl/Pose_impl.hpp b/other/myo.framework/Versions/Current/Headers/cxx/impl/Pose_impl.hpp new file mode 100755 index 0000000..7432e39 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/cxx/impl/Pose_impl.hpp @@ -0,0 +1,97 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_CXX_IMPL_POSE_IMPL_HPP +#define MYO_CXX_IMPL_POSE_IMPL_HPP + +#include "../Pose.hpp" + +#include + +namespace myo { + +inline +Pose::Pose() +: _type(unknown) +{ +} + +inline +Pose::Pose(Pose::Type type) +: _type(type) +{ +} + +inline +bool Pose::operator==(Pose other) const +{ + return _type == other._type; +} + +inline +bool Pose::operator!=(Pose other) const +{ + return !(*this == other); +} + +inline +Pose::Type Pose::type() const +{ + return _type; +} + +inline +bool operator==(Pose pose, Pose::Type type) +{ + return pose.type() == type; +} + +inline +bool operator==(Pose::Type type, Pose pose) +{ + return pose == type; +} + +inline +bool operator!=(Pose pose, Pose::Type type) +{ + return !(pose == type); +} + +inline +bool operator!=(Pose::Type type, Pose pose) +{ + return !(type == pose); +} + +inline +std::string Pose::toString() const +{ + switch (type()) { + case Pose::rest: + return "rest"; + case Pose::fist: + return "fist"; + case Pose::waveIn: + return "waveIn"; + case Pose::waveOut: + return "waveOut"; + case Pose::fingersSpread: + return "fingersSpread"; + case Pose::doubleTap: + return "doubleTap"; + case Pose::unknown: + return "unknown"; + } + + return ""; +} + +inline +std::ostream& operator<<(std::ostream& out, const Pose& pose) +{ + return out << pose.toString(); +} + +} // namespace myo + +#endif // MYO_CXX_IMPL_POSE_IMPL_HPP diff --git a/other/myo.framework/Versions/Current/Headers/libmyo.h b/other/myo.framework/Versions/Current/Headers/libmyo.h new file mode 100755 index 0000000..29a59f6 --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/libmyo.h @@ -0,0 +1,425 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_LIBMYO_H +#define MYO_LIBMYO_H + +#include + +#include "libmyo/detail/visibility.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// @file libmyo.h +/// libmyo C API declarations. + +typedef void* libmyo_hub_t; + +/// \defgroup errors Error Handling +/// @{ + +/// Function result codes. +/// All libmyo functions that can fail return a value of this type. +typedef enum { + libmyo_success, + libmyo_error, + libmyo_error_invalid_argument, + libmyo_error_runtime +} libmyo_result_t; + +/// Opaque handle to detailed error information. +typedef void* libmyo_error_details_t; + +/// Return a null-terminated string with a detailed error message. +LIBMYO_EXPORT +const char* libmyo_error_cstring(libmyo_error_details_t); + +/// Returns the kind of error that occurred. +LIBMYO_EXPORT +libmyo_result_t libmyo_error_kind(libmyo_error_details_t); + +/// Free the resources allocated by an error object. +LIBMYO_EXPORT +void libmyo_free_error_details(libmyo_error_details_t); + +/// @} + +/// \defgroup libmyo_string Strings +/// @{ + +// Opaque string. +typedef void* libmyo_string_t; + +// Return a null-terminated string from the opaque string. +LIBMYO_EXPORT +const char* libmyo_string_c_str(libmyo_string_t); + +// Free the resources allocated by the string object. +LIBMYO_EXPORT +void libmyo_string_free(libmyo_string_t); + +/// @} + +/// \defgroup libmyo_direct_mac_addresses MAC address utilities +/// @{ + +/// Retrieve the string representation of a MAC address in hex. +/// Returns a string in the format of 00-00-00-00-00-00. +LIBMYO_EXPORT +libmyo_string_t libmyo_mac_address_to_string(uint64_t); + +/// Retrieve the MAC address from a null-terminated string in the format of 00-00-00-00-00-00. +/// Returns 0 if the string does not match the format. +LIBMYO_EXPORT +uint64_t libmyo_string_to_mac_address(const char*); + +/// @} + +/// @defgroup libmyo_hub Hub instance +/// @{ + +/// Initialize a connection to the hub. +/// \a application_identifier must follow a reverse domain name format (ex. com.domainname.appname). Application +/// identifiers can be formed from the set of alphanumeric ASCII characters (a-z, A-Z, 0-9). The hyphen (-) and +/// underscore (_) characters are permitted if they are not adjacent to a period (.) character (i.e. not at the start or +/// end of each segment), but are not permitted in the top-level domain. Application identifiers must have three or more +/// segments. For example, if a company's domain is example.com and the application is named hello-world, one could use +/// "com.example.hello-world" as a valid application identifier. \a application_identifier can be NULL or empty. +/// @returns libmyo_success if the connection is successfully established, otherwise: +/// - libmyo_error_runtime if a connection could not be established +/// - libmyo_error_invalid_argument if \a out_hub is NULL +/// - libmyo_error_invalid_argument if \a application_identifier is longer than 255 characters +/// - libmyo_error_invalid_argument if \a application_identifier is not in the proper reverse domain name format +LIBMYO_EXPORT +libmyo_result_t libmyo_init_hub(libmyo_hub_t* out_hub, const char* application_identifier, + libmyo_error_details_t* out_error); + +/// Free the resources allocated to a hub. +/// @returns libmyo_success if shutdown is successful, otherwise: +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error if \a hub is not a valid hub +LIBMYO_EXPORT +libmyo_result_t libmyo_shutdown_hub(libmyo_hub_t hub, libmyo_error_details_t* out_error); + +// Locking policies. +typedef enum { + libmyo_locking_policy_none, ///< Pose events are always sent. + libmyo_locking_policy_standard ///< Pose events are not sent while a Myo is locked. +} libmyo_locking_policy_t; + +/// Set the locking policy for Myos connected to the hub. +/// @returns libmyo_success if the locking policy is successfully set, otherwise +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error if \a hub is not a valid hub +LIBMYO_EXPORT +libmyo_result_t libmyo_set_locking_policy(libmyo_hub_t hub, libmyo_locking_policy_t locking_policy, + libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_myo Myo instances +/// @{ + +/// Opaque type corresponding to a known Myo device. +typedef void* libmyo_myo_t; + +/// Types of vibration +typedef enum { + libmyo_vibration_short, + libmyo_vibration_medium, + libmyo_vibration_long +} libmyo_vibration_type_t; + +/// Retrieve the MAC address of a Myo. +/// The MAC address is unique to the physical Myo, and is a 48-bit number. +LIBMYO_EXPORT +uint64_t libmyo_get_mac_address(libmyo_myo_t myo); + +/// Vibrate the given myo. +/// Can be called when a Myo is paired. +/// @returns libmyo_success if the Myo successfully vibrated, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_vibrate(libmyo_myo_t myo, libmyo_vibration_type_t type, libmyo_error_details_t* out_error); + +/// Request the RSSI for a given myo. +/// Can be called when a Myo is paired. A libmyo_event_rssi event will likely be generated with the value of the RSSI. +/// @returns libmyo_success if the Myo successfully got the RSSI, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_request_rssi(libmyo_myo_t myo, libmyo_error_details_t* out_error); + + +/// Request the battery level for a given Myo. +/// A libmyo_event_battery_level event will be generated with the value of the battery level. +/// @returns libmyo_success if the Myo successfully requested the battery level, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_request_battery_level(libmyo_myo_t myo_opq, libmyo_error_details_t* out_error); + +/// EMG streaming modes. +typedef enum { + libmyo_stream_emg_disabled, ///< Do not send EMG data. + libmyo_stream_emg_enabled ///< Send EMG data. +} libmyo_stream_emg_t; + +/// Set whether or not to stream EMG data for a given myo. +/// Can be called when a Myo is paired. +/// @returns libmyo_success if the EMG mode was set successfully, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_set_stream_emg(libmyo_myo_t myo, libmyo_stream_emg_t emg, libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_poses Pose recognition. +/// @{ + +/// Supported poses. +typedef enum { + libmyo_pose_rest = 0, ///< Rest pose. + libmyo_pose_fist = 1, ///< User is making a fist. + libmyo_pose_wave_in = 2, ///< User has an open palm rotated towards the posterior of their wrist. + libmyo_pose_wave_out = 3, ///< User has an open palm rotated towards the anterior of their wrist. + libmyo_pose_fingers_spread = 4, ///< User has an open palm with their fingers spread away from each other. + libmyo_pose_double_tap = 5, ///< User tapped their thumb and middle finger together twice in succession. + + libmyo_num_poses, ///< Number of poses supported; not a valid pose. + + libmyo_pose_unknown = 0xffff ///< Unknown pose. +} libmyo_pose_t; + +/// @} + +/// @defgroup libmyo_locking Myo locking mechanism + +/// Valid unlock types. +typedef enum { + libmyo_unlock_timed = 0, ///< Unlock for a fixed period of time. + libmyo_unlock_hold = 1, ///< Unlock until explicitly told to re-lock. +} libmyo_unlock_type_t; + +/// Unlock the given Myo. +/// Can be called when a Myo is paired. A libmyo_event_unlocked event will be generated if the Myo was locked. +/// @returns libmyo_success if the Myo was successfully unlocked, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_unlock(libmyo_myo_t myo, libmyo_unlock_type_t type, libmyo_error_details_t* out_error); + +/// Lock the given Myo immediately. +/// Can be called when a Myo is paired. A libmyo_event_locked event will be generated if the Myo was unlocked. +/// @returns libmyo_success if the Myo was successfully locked, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_lock(libmyo_myo_t myo, libmyo_error_details_t* out_error); + +/// User action types. +typedef enum { + libmyo_user_action_single = 0, ///< User did a single, discrete action, such as pausing a video. +} libmyo_user_action_type_t; + +/// Notify the given Myo that a user action was recognized. +/// Can be called when a Myo is paired. Will cause Myo to vibrate. +/// @returns libmyo_success if the Myo was successfully notified, otherwise +/// - libmyo_error_invalid_argument if \a myo is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_myo_notify_user_action(libmyo_myo_t myo, libmyo_user_action_type_t type, + libmyo_error_details_t* out_error); + +/// @} + +/// @defgroup libmyo_events Event Handling +/// @{ + +/// Types of events. +typedef enum { + libmyo_event_paired, ///< Successfully paired with a Myo. + libmyo_event_unpaired, ///< Successfully unpaired from a Myo. + libmyo_event_connected, ///< A Myo has successfully connected. + libmyo_event_disconnected, ///< A Myo has been disconnected. + libmyo_event_arm_synced, ///< A Myo has recognized that the sync gesture has been successfully performed. + libmyo_event_arm_unsynced, ///< A Myo has been moved or removed from the arm. + libmyo_event_orientation, ///< Orientation data has been received. + libmyo_event_pose, ///< A change in pose has been detected. @see libmyo_pose_t. + libmyo_event_rssi, ///< An RSSI value has been received. + libmyo_event_unlocked, ///< A Myo has become unlocked. + libmyo_event_locked, ///< A Myo has become locked. + libmyo_event_emg, ///< EMG data has been received. + libmyo_event_battery_level, ///< A battery level value has been received. + libmyo_event_warmup_completed, ///< The warmup period has completed. +} libmyo_event_type_t; + +/// Information about an event. +typedef const void* libmyo_event_t; + +/// Retrieve the type of an event. +LIBMYO_EXPORT +uint32_t libmyo_event_get_type(libmyo_event_t event); + +/// Retrieve the timestamp of an event. +/// @see libmyo_now() for details on timestamps. +LIBMYO_EXPORT +uint64_t libmyo_event_get_timestamp(libmyo_event_t event); + +/// Retrieve the Myo associated with an event. +LIBMYO_EXPORT +libmyo_myo_t libmyo_event_get_myo(libmyo_event_t event); + +/// Retrieve the MAC address of the myo associated with an event. +LIBMYO_EXPORT +uint64_t libmyo_event_get_mac_address(libmyo_event_t event_opq); + +/// Retrieve the name of the myo associated with an event. +/// Caller must free the returned string. @see libmyo_string functions. +LIBMYO_EXPORT +libmyo_string_t libmyo_event_get_myo_name(libmyo_event_t event); + +/// Components of version. +typedef enum { + libmyo_version_major, ///< Major version. + libmyo_version_minor, ///< Minor version. + libmyo_version_patch, ///< Patch version. + libmyo_version_hardware_rev, ///< Hardware revision. +} libmyo_version_component_t; + +/// Hardware revisions. +typedef enum { + libmyo_hardware_rev_c = 1, ///< Alpha units + libmyo_hardware_rev_d = 2, ///< Consumer units +} libmyo_hardware_rev_t; + +/// Retrieve the Myo armband's firmware version from this event. +/// Valid for libmyo_event_paired and libmyo_event_connected events. +LIBMYO_EXPORT +unsigned int libmyo_event_get_firmware_version(libmyo_event_t event, libmyo_version_component_t); + +/// Enumeration identifying a right arm or left arm. @see libmyo_event_get_arm(). +typedef enum { + libmyo_arm_right, ///< Myo is on the right arm. + libmyo_arm_left, ///< Myo is on the left arm. + libmyo_arm_unknown, ///< Unknown arm. +} libmyo_arm_t; + +/// Retrieve the arm associated with an event. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_arm_t libmyo_event_get_arm(libmyo_event_t event); + +/// Possible directions for Myo's +x axis relative to a user's arm. +typedef enum { + libmyo_x_direction_toward_wrist, ///< Myo's +x axis is pointing toward the user's wrist. + libmyo_x_direction_toward_elbow, ///< Myo's +x axis is pointing toward the user's elbow. + libmyo_x_direction_unknown, ///< Unknown +x axis direction. +} libmyo_x_direction_t; + +/// Retrieve the x-direction associated with an event. +/// The x-direction specifies which way Myo's +x axis is pointing relative to the user's arm. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_x_direction_t libmyo_event_get_x_direction(libmyo_event_t event); + +/// Possible warmup states for Myo. +typedef enum { + libmyo_warmup_state_unknown = 0, ///< Unknown warm up state. + libmyo_warmup_state_cold = 1, ///< Myo needs to warm up. + libmyo_warmup_state_warm = 2, ///< Myo is already in a warmed up state. +} libmyo_warmup_state_t; + +/// Retrieve the warmup state of the Myo associated with an event. +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +libmyo_warmup_state_t libmyo_event_get_warmup_state(libmyo_event_t event); + +/// Possible warmup results for Myo. +typedef enum { + libmyo_warmup_result_unknown = 0, ///< Unknown warm up result. + libmyo_warmup_result_success = 1, ///< The warm up period has completed successfully. + libmyo_warmup_result_failed_timeout = 2, ///< The warm up period timed out. +} libmyo_warmup_result_t; + +/// Retrieve the warmup result of the Myo associated with an event. +/// Valid for libmyo_event_warmup_completed events only. +LIBMYO_EXPORT +libmyo_warmup_result_t libmyo_event_get_warmup_result(libmyo_event_t event); + +/// Retrieve the estimated rotation of Myo on the user's arm after a sync. +/// The values specifies the rotation of the myo on the arm (0 - logo facing down, pi - logo facing up) +/// Only supported by FW 1.3.x and above (older firmware will always report 0 for the rotation) +/// Valid for libmyo_event_arm_synced events only. +LIBMYO_EXPORT +float libmyo_event_get_rotation_on_arm(libmyo_event_t event); + +/// Index into orientation data, which is provided as a quaternion. +/// Orientation data is returned as a unit quaternion of floats, represented as `w + x * i + y * j + z * k`. +typedef enum { + libmyo_orientation_x = 0, ///< First component of the quaternion's vector part + libmyo_orientation_y = 1, ///< Second component of the quaternion's vector part + libmyo_orientation_z = 2, ///< Third component of the quaternion's vector part + libmyo_orientation_w = 3, ///< Scalar component of the quaternion. +} libmyo_orientation_index; + +/// Retrieve orientation data associated with an event. +/// Valid for libmyo_event_orientation events only. +/// @see libmyo_orientation_index +LIBMYO_EXPORT +float libmyo_event_get_orientation(libmyo_event_t event, libmyo_orientation_index index); + +/// Retrieve raw accelerometer data associated with an event in units of g. +/// Valid for libmyo_event_orientation events only. +/// Requires `index < 3`. +LIBMYO_EXPORT +float libmyo_event_get_accelerometer(libmyo_event_t event, unsigned int index); + +/// Retrieve raw gyroscope data associated with an event in units of deg/s. +/// Valid for libmyo_event_orientation events only. +/// Requires `index < 3`. +LIBMYO_EXPORT +float libmyo_event_get_gyroscope(libmyo_event_t event, unsigned int index); + +/// Retrieve the pose associated with an event. +/// Valid for libmyo_event_pose events only. +LIBMYO_EXPORT +libmyo_pose_t libmyo_event_get_pose(libmyo_event_t event); + +/// Retreive the RSSI associated with an event. +/// Valid for libmyo_event_rssi events only. +LIBMYO_EXPORT +int8_t libmyo_event_get_rssi(libmyo_event_t event); + +/// Retrieve the battery level of the Myo armband associated with an event. +/// Only valid for libmyo_event_battery_level event. +LIBMYO_EXPORT +uint8_t libmyo_event_get_battery_level(libmyo_event_t event); + +/// Retrieve an EMG data point associated with an event. +/// Valid for libmyo_event_emg events only. +/// @a sensor must be smaller than 8. +LIBMYO_EXPORT +int8_t libmyo_event_get_emg(libmyo_event_t event, unsigned int sensor); + +/// Return type for event handlers. +typedef enum { + libmyo_handler_continue, ///< Continue processing events + libmyo_handler_stop, ///< Stop processing events +} libmyo_handler_result_t; + +/// Callback function type to handle events as they occur from libmyo_run(). +typedef libmyo_handler_result_t (*libmyo_handler_t)(void* user_data, libmyo_event_t event); + +/// Process events and call the provided callback as they occur. +/// Runs for up to approximately \a duration_ms milliseconds or until a called handler returns libmyo_handler_stop. +/// @returns libmyo_success after a successful run, otherwise +/// - libmyo_error_invalid_argument if \a hub is NULL +/// - libmyo_error_invalid_argument if \a handler is NULL +LIBMYO_EXPORT +libmyo_result_t libmyo_run(libmyo_hub_t hub, unsigned int duration_ms, libmyo_handler_t handler, void* user_data, + libmyo_error_details_t* out_error); + +/// @} + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // MYO_LIBMYO_H diff --git a/other/myo.framework/Versions/Current/Headers/libmyo/detail/visibility.h b/other/myo.framework/Versions/Current/Headers/libmyo/detail/visibility.h new file mode 100755 index 0000000..3a23e6a --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/libmyo/detail/visibility.h @@ -0,0 +1,32 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#ifndef MYO_LIBMYO_DETAIL_VISIBILITY_H +#define MYO_LIBMYO_DETAIL_VISIBILITY_H + +#if defined(_WIN32) || defined(__CYGWIN__) + #ifdef myo_EXPORTS + #ifdef __GNUC__ + #define LIBMYO_EXPORT __attribute__ ((dllexport)) + #else + #define LIBMYO_EXPORT __declspec(dllexport) + #endif + #else + #ifdef LIBMYO_STATIC_BUILD + #define LIBMYO_EXPORT + #else + #ifdef __GNUC__ + #define LIBMYO_EXPORT __attribute__ ((dllimport)) + #else + #define LIBMYO_EXPORT __declspec(dllimport) + #endif + #endif + #endif +#else + #if __GNUC__ >= 4 + #define LIBMYO_EXPORT __attribute__ ((visibility ("default"))) + #else + #define LIBMYO_EXPORT + #endif +#endif + +#endif // MYO_LIBMYO_DETAIL_VISIBILITY_H diff --git a/other/myo.framework/Versions/Current/Headers/myo.hpp b/other/myo.framework/Versions/Current/Headers/myo.hpp new file mode 100755 index 0000000..5ea17fb --- /dev/null +++ b/other/myo.framework/Versions/Current/Headers/myo.hpp @@ -0,0 +1,13 @@ +// Copyright (C) 2013-2014 Thalmic Labs Inc. +// Distributed under the Myo SDK license agreement. See LICENSE.txt for details. +#pragma once + +/// The namespace in which all of the %Myo C++ bindings are contained. +namespace myo {} + +#include "cxx/DeviceListener.hpp" +#include "cxx/Hub.hpp" +#include "cxx/Myo.hpp" +#include "cxx/Pose.hpp" +#include "cxx/Quaternion.hpp" +#include "cxx/Vector3.hpp" diff --git a/other/myo.framework/Versions/Current/Resources/Info.plist b/other/myo.framework/Versions/Current/Resources/Info.plist new file mode 100755 index 0000000..aeec5cc --- /dev/null +++ b/other/myo.framework/Versions/Current/Resources/Info.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + myo + CFBundleIconFile + + CFBundleIdentifier + + CFBundleInfoDictionaryVersion + 6.0 + CFBundlePackageType + FMWK + CFBundleSignature + ???? + CFBundleVersion + + CFBundleShortVersionString + + CSResourcesFileMapped + + + diff --git a/other/myo.framework/Versions/Current/_CodeSignature/CodeResources b/other/myo.framework/Versions/Current/_CodeSignature/CodeResources new file mode 100755 index 0000000..94014f5 --- /dev/null +++ b/other/myo.framework/Versions/Current/_CodeSignature/CodeResources @@ -0,0 +1,167 @@ + + + + + files + + Resources/Info.plist + + tUgLZV94WtJ7c7dl1ZQDEnyfe2U= + + + files2 + + Headers/cxx/DeviceListener.hpp + + 5frQIrDj5Rod49qbH8F/ODv03cg= + + Headers/cxx/Hub.hpp + + i2GwmXkJaAf8ZK1boAQLVFA9FuQ= + + Headers/cxx/Myo.hpp + + zkwa8CxGu7CxuY09ncg4cs2C0Ik= + + Headers/cxx/Pose.hpp + + bV/b65asnTpOQVVUseBE2Jks2yY= + + Headers/cxx/Quaternion.hpp + + bvsi/ZwGqVs0ZiHbWPUtsWlsK8k= + + Headers/cxx/Vector3.hpp + + OQUYhjK6FE/MwW8eyy24OtbHO4I= + + Headers/cxx/detail/ThrowOnError.hpp + + ZG7+E/cEH4UadH/3StifiGVjRxE= + + Headers/cxx/impl/Hub_impl.hpp + + jPk/hrtJnF4CumxpYjsOPpHH8PM= + + Headers/cxx/impl/Myo_impl.hpp + + 1IleanLjzRkjPeQaDU5tHCnz3+k= + + Headers/cxx/impl/Pose_impl.hpp + + dimtyDcx8DWcpkDi1creWJADmRA= + + Headers/libmyo.h + + 0nJ1nA0iCBjWxuXv2VZ2vRHjXnY= + + Headers/libmyo/detail/visibility.h + + dPUWLcemRGRDAJVc1Gonqqzo2K0= + + Headers/myo.hpp + + JeFdPeQ4BqtfHJyJxRiXrDHj6xw= + + Resources/Info.plist + + tUgLZV94WtJ7c7dl1ZQDEnyfe2U= + + + rules + + ^Resources/ + + ^Resources/.*\.lproj/ + + optional + + weight + 1000 + + ^Resources/.*\.lproj/locversion.plist$ + + omit + + weight + 1100 + + ^version.plist$ + + + rules2 + + .*\.dSYM($|/) + + weight + 11 + + ^(.*/)?\.DS_Store$ + + omit + + weight + 2000 + + ^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/ + + nested + + weight + 10 + + ^.* + + ^Info\.plist$ + + omit + + weight + 20 + + ^PkgInfo$ + + omit + + weight + 20 + + ^Resources/ + + weight + 20 + + ^Resources/.*\.lproj/ + + optional + + weight + 1000 + + ^Resources/.*\.lproj/locversion.plist$ + + omit + + weight + 1100 + + ^[^/]+$ + + nested + + weight + 10 + + ^embedded\.provisionprofile$ + + weight + 20 + + ^version\.plist$ + + weight + 20 + + + + diff --git a/other/myo.framework/Versions/Current/myo b/other/myo.framework/Versions/Current/myo new file mode 100755 index 0000000..ba6e3e9 Binary files /dev/null and b/other/myo.framework/Versions/Current/myo differ diff --git a/other/myo.framework/myo b/other/myo.framework/myo new file mode 100755 index 0000000..ba6e3e9 Binary files /dev/null and b/other/myo.framework/myo differ diff --git a/patchers/main.maxpat b/patchers/main.maxpat new file mode 100644 index 0000000..acc3223 --- /dev/null +++ b/patchers/main.maxpat @@ -0,0 +1,46 @@ +{ + "patcher" : { + "fileversion" : 1, + "appversion" : { + "major" : 8, + "minor" : 0, + "revision" : 8, + "architecture" : "x64", + "modernui" : 1 + } +, + "classnamespace" : "box", + "rect" : [ 0.0, 0.0, 640.0, 480.0 ], + "bglocked" : 0, + "openinpresentation" : 0, + "default_fontsize" : 12.0, + "default_fontface" : 0, + "default_fontname" : "Arial", + "gridonopen" : 1, + "gridsize" : [ 15.0, 15.0 ], + "gridsnaponopen" : 1, + "objectsnaponopen" : 1, + "statusbarvisible" : 2, + "toolbarvisible" : 1, + "lefttoolbarpinned" : 0, + "toptoolbarpinned" : 0, + "righttoolbarpinned" : 0, + "bottomtoolbarpinned" : 0, + "toolbars_unpinned_last_save" : 0, + "tallnewobj" : 0, + "boxanimatetime" : 200, + "enablehscroll" : 1, + "enablevscroll" : 1, + "devicewidth" : 0.0, + "description" : "", + "digest" : "", + "tags" : "", + "style" : "", + "subpatcher_template" : "", + "boxes" : [ ], + "lines" : [ ], + "dependency_cache" : [ ], + "autosave" : 0 + } + +}