Quella/unitreeApp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Quella
2025-09-24 10:53:28 +08:00
commit f8e4df77fb
856 changed files with 140098 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
unitree_SDK/include/unitree/robot/channel/channel_factory.hpp Normal file
View File

@@ -0,0 +1,62 @@
#ifndef __UT_ROBOT_SDK_CHANNEL_FACTORY_HPP__
#define __UT_ROBOT_SDK_CHANNEL_FACTORY_HPP__
#include <unitree/common/dds/dds_factory_model.hpp>
namespace unitree
{
namespace robot
{
template<typename MSG>
using Channel = unitree::common::DdsTopicChannel<MSG>;
template<typename MSG>
using ChannelPtr = unitree::common::DdsTopicChannelPtr<MSG>;
class ChannelFactory
{
public:
static ChannelFactory* Instance()
{
static ChannelFactory inst;
return &inst;
}
void Init(int32_t domainId, const std::string& networkInterface = "");
void Init(const std::string& configFileName = "");
void Init(const common::JsonMap& jsonMap);
void Release();
template<typename MSG>
ChannelPtr<MSG> CreateSendChannel(const std::string& name)
{
ChannelPtr<MSG> channelPtr = mDdsFactoryPtr->CreateTopicChannel<MSG>(name);
mDdsFactoryPtr->SetWriter(channelPtr);
return channelPtr;
}
template<typename MSG>
ChannelPtr<MSG> CreateRecvChannel(const std::string& name, std::function<void(const void*)> callback, int32_t queuelen = 0)
{
ChannelPtr<MSG> channelPtr = mDdsFactoryPtr->CreateTopicChannel<MSG>(name);
mDdsFactoryPtr->SetReader(channelPtr, callback, queuelen);
return channelPtr;
}
public:
~ChannelFactory();
private:
ChannelFactory();
private:
bool mInited;
common::DdsFactoryModelPtr mDdsFactoryPtr;
common::Mutex mMutex;
};
}
}
#endif//__UT_ROBOT_SDK_CHANNEL_FACTORY_HPP__

99
unitree_SDK/include/unitree/robot/channel/channel_labor.hpp Normal file
View File

@@ -0,0 +1,99 @@
#ifndef __UT_ROBOT_SDK_CHANNEL_LABOR_HPP__
#define __UT_ROBOT_SDK_CHANNEL_LABOR_HPP__
#include <unitree/robot/channel/channel_factory.hpp>
#include <unitree/robot/channel/channel_namer.hpp>
#include <unitree/common/time/time_tool.hpp>
namespace unitree
{
namespace robot
{
/*
* @brief
* @class: ChannelLabor
*/
template<typename SEND_MSG, typename RECV_MSG>
class ChannelLabor
{
public:
ChannelLabor()
{}
virtual ~ChannelLabor()
{}
void InitChannel(const std::string& name, const std::function<void(const void*)>& recvMesageCallback, int32_t queuelen = 0)
{
std::string sendChannelName = mNamerPtr->GetSendChannelName(name);
std::string recvChannelName = mNamerPtr->GetRecvChannelName(name);
mSendChannlPtr = ChannelFactory::Instance()->CreateSendChannel<SEND_MSG>(sendChannelName);
mRecvChannlPtr = ChannelFactory::Instance()->CreateRecvChannel<RECV_MSG>(recvChannelName, recvMesageCallback, queuelen);
}
bool Send(const SEND_MSG& msg, int64_t waitTimeout)
{
return mSendChannlPtr->Write(msg, waitTimeout);
}
int64_t GetLastDataAvailableTime() const
{
return mRecvChannlPtr->GetLastDataAvailableTime();
}
protected:
ChannelNamerPtr mNamerPtr;
private:
ChannelPtr<SEND_MSG> mSendChannlPtr;
ChannelPtr<RECV_MSG> mRecvChannlPtr;
};
template<typename SEND_MSG, typename RECV_MSG>
using ChannelLaborPtr = std::shared_ptr<ChannelLabor<SEND_MSG,RECV_MSG>>;
/*
* @brief
* @class: ClientChannelLabor
*/
template<typename SEND_MSG, typename RECV_MSG>
class ClientChannelLabor : public ChannelLabor<SEND_MSG,RECV_MSG>
{
public:
ClientChannelLabor()
{
ChannelLabor<SEND_MSG,RECV_MSG>::mNamerPtr = ChannelNamerPtr(new ClientChannelNamer());
}
~ClientChannelLabor()
{}
};
template<typename SEND_MSG, typename RECV_MSG>
using ClientChannelLaborPtr = std::shared_ptr<ClientChannelLabor<SEND_MSG,RECV_MSG>>;
/*
* @brief
* @class: ServerChannelLabor
*/
template<typename SEND_MSG, typename RECV_MSG>
class ServerChannelLabor : public ChannelLabor<SEND_MSG,RECV_MSG>
{
public:
ServerChannelLabor()
{
ChannelLabor<SEND_MSG,RECV_MSG>::mNamerPtr = ChannelNamerPtr(new ServerChannelNamer());
}
~ServerChannelLabor()
{}
};
template<typename SEND_MSG, typename RECV_MSG>
using ServerChannelLaborPtr = std::shared_ptr<ServerChannelLabor<RECV_MSG,SEND_MSG>>;
}
}
#endif//__UT_ROBOT_SDK_CHANNEL_LABOR_HPP__

64
unitree_SDK/include/unitree/robot/channel/channel_namer.hpp Normal file
View File

@@ -0,0 +1,64 @@
#ifndef __UT_ROBOT_SDK_CHANNEL_NAMER_HPP__
#define __UT_ROBOT_SDK_CHANNEL_NAMER_HPP__
#include <unitree/common/decl.hpp>
namespace unitree
{
namespace robot
{
const std::string ROBOT_SDK_CHANNEL_PREFIX = "rt/api/";
const std::string ROBOT_SDK_CHANNEL_SUFFIX_CLIENT = "/request";
const std::string ROBOT_SDK_CHANNEL_SUFFIX_SERVER = "/response";
/*
* @brief
* @class: ChannelNamer
*/
class ChannelNamer
{
public:
virtual std::string GetSendChannelName(const std::string& name) = 0;
virtual std::string GetRecvChannelName(const std::string& name) = 0;
};
using ChannelNamerPtr = std::shared_ptr<ChannelNamer>;
/*
* @brief
* @class: ClientChannelNamer
*/
class ClientChannelNamer : public ChannelNamer
{
public:
ClientChannelNamer();
~ClientChannelNamer();
protected:
std::string GetSendChannelName(const std::string& name);
std::string GetRecvChannelName(const std::string& name);
};
using ClientChannelNamerPtr = std::shared_ptr<ClientChannelNamer>;
/*
* @brief
* @class: ServerChannelNamer
*/
class ServerChannelNamer : public ChannelNamer
{
public:
ServerChannelNamer();
virtual ~ServerChannelNamer();
protected:
std::string GetSendChannelName(const std::string& name);
std::string GetRecvChannelName(const std::string& name);
};
using ServerChannelNamerPtr = std::shared_ptr<ServerChannelNamer>;
}
}
#endif//__UT_ROBOT_SDK_CHANNEL_NAMER_HPP__

54
unitree_SDK/include/unitree/robot/channel/channel_publisher.hpp Normal file
View File

@@ -0,0 +1,54 @@
#ifndef __UT_ROBOT_SDK_CHANNEL_PUBLISHER_HPP__
#define __UT_ROBOT_SDK_CHANNEL_PUBLISHER_HPP__
#include <unitree/robot/channel/channel_factory.hpp>
namespace unitree
{
namespace robot
{
template<typename MSG>
class ChannelPublisher
{
public:
explicit ChannelPublisher(const std::string& channelName) :
mChannelName(channelName)
{}
void InitChannel()
{
mChannelPtr = ChannelFactory::Instance()->CreateSendChannel<MSG>(mChannelName);
}
bool Write(const MSG& msg, int64_t waitMicrosec = 0)
{
if (mChannelPtr)
{
return mChannelPtr->Write(msg, waitMicrosec);
}
return false;
}
void CloseChannel()
{
mChannelPtr.reset();
}
const std::string& GetChannelName() const
{
return mChannelName;
}
private:
std::string mChannelName;
ChannelPtr<MSG> mChannelPtr;
};
template<typename MSG>
using ChannelPublisherPtr = std::shared_ptr<ChannelPublisher<MSG>>;
}
}
#endif//__UT_ROBOT_SDK_CHANNEL_PUBLISHER_HPP__

75
unitree_SDK/include/unitree/robot/channel/channel_subscriber.hpp Normal file
View File

@@ -0,0 +1,75 @@
#ifndef __UT_ROBOT_SDK_CHANNEL_SUBSCRIBER_HPP__
#define __UT_ROBOT_SDK_CHANNEL_SUBSCRIBER_HPP__
#include <unitree/robot/channel/channel_factory.hpp>
namespace unitree
{
namespace robot
{
template<typename MSG>
class ChannelSubscriber
{
public:
explicit ChannelSubscriber(const std::string& channelName) :
mChannelName(channelName), mQueueLen(0)
{}
explicit ChannelSubscriber(const std::string& channelName, const std::function<void(const void*)>& handler, int64_t queuelen = 0) :
mChannelName(channelName), mQueueLen(queuelen), mHandler(handler)
{}
void InitChannel(const std::function<void(const void*)>& handler, int64_t queuelen = 0)
{
mHandler = handler;
mQueueLen = queuelen;
InitChannel();
}
void InitChannel()
{
if (mHandler)
{
mChannelPtr = ChannelFactory::Instance()->CreateRecvChannel<MSG>(mChannelName, mHandler, mQueueLen);
}
else
{
UT_THROW(common::CommonException, "subscribe handler is invalid");
}
}
void CloseChannel()
{
mChannelPtr.reset();
}
int64_t GetLastDataAvailableTime() const
{
if (mChannelPtr)
{
return mChannelPtr->GetLastDataAvailableTime();
}
return -1;
}
const std::string& GetChannelName() const
{
return mChannelName;
}
private:
std::string mChannelName;
int64_t mQueueLen;
std::function<void(const void*)> mHandler;
ChannelPtr<MSG> mChannelPtr;
};
template<typename MSG>
using ChannelSubscriberPtr = std::shared_ptr<ChannelSubscriber<MSG>>;
}
}
#endif//__UT_ROBOT_SDK_CHANNEL_SUBSCRIBER_HPP__