支架仿真系统的实现

耗时一个多月，完成了放顶煤、薄煤层液压支架仿真程序的编写。

主要思想：

偶也是菜鸟，刚开始想用骨骼动画实现，但是没有人可给帮我做机械的骨骼动画，只好放弃。

第二种思路，想用Max导出的关键帧动画来实现，每个支架有非常多的动作，十几种，每种动作与其他动作都有可能同时发生，用Max做好关键帧动画之后，导出时分段导出动画，对每个动作分别进行导出，导出后导入程序，当两个动作同时播放时发现模型裂了，如图：，纠结起原因，读OgreMax导入场景的代码，发现当播放两个动作时，此时模型的每个mesh都做了两次位移、旋转、等等，肯定会裂开，同时播放几个动画，此时模型就会位移几次~~，研究了将近一周的时间，美工没有用过OgreMax，加上我是个菜鸟~~最后多方求友，不得不放弃，（如果那位网友知道如何避免这个问题，请不吝赐教）。

最后不得不采用控制节点，使用节点动画来实现，通过一个controller来实现，因为最终模型需要通过硬件来控制，控制器与PC是通过串口进行通讯的，所以本程序共分为三个部分：

1、通讯部分

           通过串口，不同的支架传输不同字节长度的数据，根据数据的某一位控制支架做相应的动作。在数据传输过程中使用CRC校验。

示例代码如下：

unsigned short CRC16(unsigned char * puchMsg, unsigned short usDataLen)
{
    unsigned char uchCRCHi = 0xFF ; /* 高CRC 字节初始化 */
    unsigned char uchCRCLo = 0xFF ; /* 低CRC 字节初始化 */
    unsigned uIndex ; /* CRC 循环中的索引 */
    while (usDataLen--) /* 传输消息缓冲区 */
    {
        uIndex = uchCRCHi ^ *(puchMsg++) ; /* 计算CRC */
        uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
        uchCRCLo = auchCRCLo[uIndex] ;
    }
    return (uchCRCHi << 8 | uchCRCLo) ;
}

//构造液压支架通信命令
int make_support_command(const char * buf, int cnt, std::vector<char>& result)
{
    result.resize(cnt+3);
    result[0] = 0xaf;

    memcpy(&result[1], buf, cnt);

    unsigned short crc = CRC16((unsigned char *)&result[0], cnt+1);
    result[cnt + 1] = crc >> 8;
    result[cnt + 2] = crc & 0xff;

    return cnt+3;
}

//CRC校验
int check_support_command(const char * buf, int cnt, std::vector<char>& result)
{
    //if(cnt != 9)
    //{
    //    TRACE(_T("数据长度错误！\n"));
    //    //AfxMessageBox(_T("数据长度错误！"));
    //}

    unsigned short recv_crc = CRC16((unsigned char *)(buf+0), cnt-2);
    unsigned short send_crc = *((unsigned char *)(buf+1 + cnt-3));
    send_crc <<= 8;
    send_crc |= *((unsigned char *)(buf+2 + cnt-3));
    if(send_crc != recv_crc)
    {
        TRACE(_T("校验码错误！\n"));
        //AfxMessageBox(_T("校验码错误！"));
        return -1;
    }

    result.resize(cnt-3);
    memcpy(&result[0], buf+1, cnt-3);

    return cnt-3;
}

2、支架组装，定义部分

   此部分将支架组装，使用了一种极其笨拙的方法，将支架的各个部分使用OgreMax导出后，然后根据OgreMax导出的scene文件的坐标值，然后在程序中组装支架。定义的变量相当繁琐，有很大缺陷，当换一个支架的时候，程序的数据需要重写。就是根据支架的结构创建支架，将支架的各个部分一一组装起来。代码如下：

mSupportRoot = mSManager->getRootSceneNode()->createChildSceneNode(mName);
    mFulcrum     = mSupportRoot->createChildSceneNode(mName + "supportFulrum", Vector3(0, 0, 0));

    //推溜节点
    mMoveSupport = mSupportRoot->createChildSceneNode(mName + "moveSupport", Vector3(-1.18005, 0.115254, 0));
    Entity *e = mSManager->createEntity(mName + "moveSupport", "TSmoveSupport.mesh");
    mMoveSupport->attachObject(e);

    mScraper = mMoveSupport->createChildSceneNode(mName + "scraper", Vector3(-1.03653, -0.0424172, 0));
    e = mSManager->createEntity(mName + "scraper", "TSscraper.mesh");
    mScraper->attachObject(e);
    mScraper->setVisible(mIsShowScraper);

    //底座节点
    mBase = mFulcrum->createChildSceneNode(mName + "supportBase");
    e = mSManager->createEntity(mName + "base", "TSbase.mesh");
    mBase->attachObject(e);
    mBasePillar = mBase->createChildSceneNode(mName + "basePillar", Vector3(-1.05936, 0.141, 0));

    //抬底节点
    mLiftBase = mFulcrum->createChildSceneNode(mName + "liftBase", Vector3(-1.26348, 0.30187, 0));
    e = mSManager->createEntity(mName + "liftBase", "TSliftBase.mesh");
    mLiftBase->attachObject(e);

    //下立柱节点
    mDownPillar = mBase->createChildSceneNode(mName + "downPillar", Vector3(-1.07193, 0.538018, 0));
    e = mSManager->createEntity(mName + "downPillar", "TSdownPillar.mesh");
    mDownPillar->attachObject(e);
    mDownPillar->setOrientation(0.989742, 0, 0, 0.142869);

    //上立柱节点
    //mUpPillar = mDownPillar->createChildSceneNode(mName + "upPillar", Vector3(-0.13854,0.961672, 0));
    //mUpPillar = mDownPillar->createChildSceneNode(mName + "upPillar", Vector3(0, 0.961672, 0));
    mUpPillar = mDownPillar->createChildSceneNode(mName + "upPillar", Vector3(0, 1.181672, 0));
    e = mSManager->createEntity(mName + "upPillar", "TSupPillar.mesh");
    mUpPillar->attachObject(e);
    //mUpPillar->setOrientation(0.997184, 0, 0, 0.0749965);

    //顶梁节点
    mTopBeamAxis  = mUpPillar->createChildSceneNode(mName + "topBeamAxis", Vector3(0.00674, -0.00362, 0));
    mTopBeamAxis->roll(Radian(Math::DegreesToRadians(-17)));
    mTopBeam      = mTopBeamAxis->createChildSceneNode(mName + "topBeam");
    mTopPillar    = mUpPillar->createChildSceneNode(mName + "topPillar");
    //mTopBeamTrack = mTopBeamAxis->createChildSceneNode(mName + "topBeamTrack", Vector3(0.915483, -0.10226, 0));
    mTopBeamTrack = mTopBeamAxis->createChildSceneNode(mName + "topBeamTrack", Vector3(/*0.915483*/0.715483, -0.10226, 0));
    //e = mSManager->createEntity("TStopTarget", "ninja.mesh");
    //mTopBeamTrack->attachObject(e);
    //mTopBeamTrack->setScale(0.001, 0.001, 0.001);
    e = mSManager->createEntity(mName + "topBeam", "TStopBeam.mesh");
    mTopBeam->attachObject(e);

    //恻护节点
    mSideGuard = mTopBeam->createChildSceneNode(mName + "sideGurad", Vector3(-0.00456, -0.00654, 0));
    e = mSManager->createEntity(mName +"sideGuard", "TSsideGuard.mesh");
    mSideGuard->attachObject(e);

    //平衡千斤顶顶梁部分
    mShieldJack2Axis = mTopBeam->createChildSceneNode(mName + "shiledJack2Axis", Vector3(0.435347, -0.00176, 0));
    mShieldJack2Axis->setInheritOrientation(false);
    mShieldJack2 = mShieldJack2Axis->createChildSceneNode(mName + "ShieldJack1");
    mShieldJack2->setOrientation(0.907374, 0, 0, 0.420324);
    e = mSManager->createEntity(mName + "shieldJack2", "TSshieldJack2.mesh");
    mShieldJack2->attachObject(e);

    //掩护梁节点
    mShieldBeamAxis = mTopBeam->createChildSceneNode(mName + "shieldBeamAxis", Vector3(0.715483, -0.01226, 0));
    mShieldBeamAxis->setOrientation(0.909066, 0, 0, -0.416652);
    //mShieldBeamAxis->roll(Radian(Degree(-50)));
    mShieldBeam = mShieldBeamAxis->createChildSceneNode(mName + "shieldBeam");
    mShieldBeam->translate(0.35, 0.05, 0, Node::TransformSpace::TS_LOCAL);
    e = mSManager->createEntity(mName + "shieldBeam", "TSshieldBeam.mesh");
    mShieldBeam->attachObject(e);
    //mShieldBeam->setVisible(false);

    //掩护梁恻护节点
    mShieldSideGuard = mShieldBeam->createChildSceneNode(mName + "shieldSideGuard", Vector3(0, 0, -0.503772));
    e = mSManager->createEntity(mName + "shieldSideGuard", "TSshieldSideGuard.mesh");
    mShieldSideGuard->attachObject(e);

    //平衡千斤顶掩护梁部分节点
    //mShieldJack2Axis = mShieldBeam->createChildSceneNode(mName + "shieldJack2Axis", Vector3(-0.074592, -0.184284, 0));
    mShieldJack1Axis = mShieldBeam->createChildSceneNode(mName + "shieldJack1Axis", Vector3(0.1 ,-0.104284, 0));
    mShieldJack1Axis->setInheritOrientation(false);
    mShieldJack1 = mShieldJack1Axis->createChildSceneNode(mName + "shieldJack1");
    e = mSManager->createEntity(mName + "shieldJack1", "TSshieldJack1.mesh");
    mShieldJack1->attachObject(e);


    mShieldJack2->setAutoTracking(true, mShieldJack1Axis, Vector3::NEGATIVE_UNIT_Y);
    mShieldJack1->setAutoTracking(true, mShieldJack2Axis, Vector3::UNIT_Y);

    //mFrontRodTarget = mShieldBeam->createChildSceneNode(mName + "frontRodTarget", Vector3(0.0817407, -0.278777, 0));
    SceneNode *mFrontTargetTo = mShieldBeam->createChildSceneNode(mName + "frontRodTargetTo", Vector3(0.3517407, -0.098777, 0));
    mFrontRodTarget = mShieldBeam->createChildSceneNode(mName + "frontRodTarget", Vector3(0.0517407, -0.178777, 0));
    //e = mSManager->createEntity("frontRodTarget", "ninja.mesh");
    //mFrontRodTarget->attachObject(e);
    //mFrontRodTarget->setScale(0.0005, 0.0005, 0.0005);
    mFrontRodAxis = mBase->createChildSceneNode(mName + "frontRodAxis", Vector3(-0.579555, 0.413417, 0));
    mFrontRod = mFrontRodAxis->createChildSceneNode(mName + "frontRod");
    e = mSManager->createEntity(mName + "frontRod", "TSfrontRod.mesh");
    mFrontRod->attachObject(e);


    //mBackRodTarget = mShieldBeam->createChildSceneNode(mName + "backRodTarget", Vector3(0.245769, -0.543867, 0));
    SceneNode *mBackRodTo = mShieldBeam->createChildSceneNode(mName + "backRodTargetTo", Vector3(0.68769, -0.05, 0));
    mBackRodTarget = mShieldBeam->createChildSceneNode(mName + "backRodTarget", Vector3(0.00769, -0.05, 0));
    //e = mSManager->createEntity("backRodTarget", "ninja.mesh");
    //mBackRodTarget->attachObject(e);
    //mBackRodTarget->setScale(0.0005, 0.0005, 0.0005);
    mBackRodAxis = mBase->createChildSceneNode(mName + "backRodAxis", Vector3(-0.201678, 0.140705, 0));
    mBackRod = mBackRodAxis->createChildSceneNode(mName + "backRod");
    e = mSManager->createEntity(mName + "backRod", "TSbackRod.mesh");
    mBackRod->attachObject(e);

    mFrontRod->setAutoTracking(true, mFrontTargetTo, Vector3::UNIT_Y);
    mBackRod->setAutoTracking(true, mBackRodTo, Vector3::UNIT_Y);

3、动画控制部分

对于每个动作创建一个动画控制器（controller），根据动作的速度与每一帧的时间控制支架做动作，创建的动画控制器为createFrameTimePassthroughController，这样就可以使用frame time传递给控制器函数（controller function）。

为每个动作定义一个控制器，控制其中对每个支架的各个部分进行控制。在处理多个部分联动的时候可能要稍微注意一下，需要注意各部分的关系，本程序中在液压支架进行升柱、降柱的时候进对液压支架的顶梁、掩护梁、后连杆、底座、立柱进行了一系列余弦定理的处理，保证其动作的准确性。代码如下：

public:
    MonitorControllerValuePtr          mTopPillarDownController;          //上立柱降柱动画控制器
    MonitorControllerValuePtr          mTopPillarUpController;            //上立柱升柱动画控制器
    MonitorControllerValuePtr          mDownPillarDownController;         //下立柱降柱动画控制器
    MonitorControllerValuePtr          mDownPillarUpController;           //下立柱升柱动画控制器

    MonitorControllerValuePtr          mBaseFrontController;              //移架动画控制器
    MonitorControllerValuePtr          mScraperPushController;            //推溜动画控制器

    MonitorControllerValuePtr          mBalancePullController;            //伸平衡动画控制器
    MonitorControllerValuePtr          mBalancePushController;            //收平衡动画控制器

    MonitorControllerValuePtr          mTopAngleCalController;            //顶梁角度控制器

ControllerManager &contMgr = ControllerManager::getSingleton();

    //上立柱降柱动画控制器
    mTopPillarDownController = MonitorControllerValuePtr(new MovePillarDown(mUpPillar,  1.03, mSpeedPillarDown, this));
    contMgr.createFrameTimePassthroughController(mTopPillarDownController);
    MonitorControlDest *pController = (MonitorControlDest *)mTopPillarDownController.get();

    //上立柱升柱动画控制器
    //mTopPillarUpController = MonitorControllerValuePtr(new MovePillarUp(mUpPillar, 1.49607, mSpeedPillarUp, this));
    mTopPillarUpController = MonitorControllerValuePtr(new MovePillarUp(mUpPillar, 1.181672, mSpeedPillarUp, this));
    contMgr.createFrameTimePassthroughController(mTopPillarUpController);

    //下立柱降柱动画控制器
    mDownPillarDownController = MonitorControllerValuePtr(new MovePillarDown(mDownPillar, 0.168, mSpeedPillarDown, this));
    contMgr.createFrameTimePassthroughController(mDownPillarDownController);

    //下立柱升柱动画控制器
    mDownPillarUpController = MonitorControllerValuePtr(new MovePillarUp(mDownPillar, 0.538018, mSpeedPillarUp, this));
    contMgr.createFrameTimePassthroughController(mDownPillarUpController);

    //伸平衡动画控制器
    mBalancePullController = MonitorControllerValuePtr(new PullBalance(mShieldBeamAxis, 3.0, mSpeedBalance, this));
    contMgr.createFrameTimePassthroughController(mBalancePullController);

    //收平衡动画控制器
    mBalancePushController = MonitorControllerValuePtr(new PushBalance(mShieldBeamAxis, 3.0, mSpeedBalance, this));
    contMgr.createFrameTimePassthroughController(mBalancePushController);

    //推流动画控制器
    mScraperPushController = MonitorControllerValuePtr(new MoveScraperFront(mMoveSupport, mFulcrum, 2.0, mSpeedPush));
    contMgr.createFrameTimePassthroughController(mScraperPushController);

    //移架动画控制器
    mBaseFrontController = MonitorControllerValuePtr(new MoveScraperFront(mFulcrum, mMoveSupport, -1.18005, mSpeedMove));
    contMgr.createFrameTimePassthroughController(mBaseFrontController);

    mTopAngleCalController = MonitorControllerValuePtr(new CalAngle(this));
    contMgr.createFrameTimePassthroughController(mTopAngleCalController);

各个控制器，控制函数定义代码：

class MonitorControlDest : public Ogre::ControllerValue<Ogre::Real>
{
public:
    MonitorControlDest() : mControlValue(0), mControlFlow(0){}

    //设置控制值
    void setControlValue(Ogre::Real controlValue)
    {
        mControlValue = controlValue;
    }

    //得到控制值
    Ogre::Real getControlValue()
    {
        return mControlValue;
    }

    //设置动画控制器
    void setControlFlow(ControlFlow *pFlow)
    {
        mControlFlow = pFlow;
    }

    //得到动画控制器
    ControlFlow* getControlFlow()
    {
        return mControlFlow;
    }
protected:
    Ogre::Real    mControlValue;           //控制值
    ControlFlow   *mControlFlow;           //流程动画控制器
};

 //收平衡动画控制器
class PushBalance : public MonitorControlDest
{
public:
    PushBalance(Ogre::SceneNode *node, Ogre::Real stopPos, Ogre::Real speed, ThinSeamSupport *support)
        : mNode(node), mStopPos(stopPos), mSpeed(speed), mSupport(support)
    {

    }

    //得到当前的值
    virtual Ogre::Real getValue(void) const
    {
        if(mNode)
            return mNode->getOrientation().getPitch().valueDegrees();
        return 0;
    }

    //设置当前值
    virtual void setValue(Ogre::Real value);
protected:
    Ogre::SceneNode         *mNode;           //被控制对象
    Ogre::Radian             mStopPos;        //停止位置
    Ogre::Real               mSpeed;          //速度
    ThinSeamSupport         *mSupport;        //液压支架对象
};

程序运行如下：