便携式航电实时系统测试平台实时脚本介绍

/** 系统固定头文件 */
#include <Rasl/rasl.hpp>
#include <DataUploader/DataUploader.hpp>
#include "StaticVariable.h"
#include "rasl-dpd/user.hpp"
#include "UserChannels.rasi"
#include "DataCollect.hpp"
/** 系统固定头文件 */
//#define MC_APPNAME "M1553-TEST"
#include <Rasl/rasl.hpp>

namespace {

      using namespace Kiyun::LowerComputer;
    using namespace Kiyun::LowerComputer::Rasl;
    using namespace Kiyun::LowerComputer::Rasl::Frame;
    using namespace Kiyun::LowerComputer::Rasl::Device;   //通道设备命名空间
    using namespace Kiyun::LowerComputer::DataUploader;   //数据上传命名空间
    using namespace Kiyun::Channel;
    using namespace Kiyun::DataCollect;                   //数据采集接口命名空间
    using namespace Dpdp;                                 //协议命名空间
      
      using namespace std;
      using namespace Mince::LowerComputer::Rasl;
      using namespace Mince::LowerComputer::Rasl::Frame;
      using namespace Mince::LowerComputer::Rasl::Device;
      void fc_msgPrint(M1553_T::RecvMsg_T* rmsg, size_t size);
      void fc_msgPrint(const std::vector<uint8_t>& buf);
}

int test1553() 
{

      MCIO(log) << "-------------1553 TEST-----------------";
      if (!mt.isValid()) {
            MCIO(err) << "bm is inValid...exit";
            return -1;
      }
      if (!dsp.isValid()) {
            MCIO(err) << "dsp is inValid...exit";
            return -1;
      }

      uint16_t outData[32] = {0};
      for (int i = 0; i < 32; i++)
            outData[i] = 0x1234 + i;

      //BC to RT
      bc0.write(outData, 32);

      //RT to BC
      outData[0] = 0x4321;
      rt5.write(outData, 32);

      //RT to RT
      outData[0] = 0x2134;
      rt2.write(outData, 32);

      //执行消息
      dsp.write(0);
      dsp.write(1);
      dsp.write(2);


      //延时保证消息已处理
      Timer_T::delay(0.1);

      MCIO(log) << "-------------BC READ-----------------";
      fc_msgPrint(bc0.read());
      fc_msgPrint(bc1.read());
      fc_msgPrint(bc2.read());



      MCIO(log) << "-------------RT READ-----------------";
      MCIO(log) << "------rt 2,7 read";
      fc_msgPrint(rt2.read());
      MCIO(log) << "------rt 5,8 read";
      fc_msgPrint(rt5.read());
     

      MCIO(log) << "-------------MT READ-----------------";

      //fc_msgPrint(mt.read());
      M1553_T::RecvMsg_T rmsg[10];
      size_t res = 0;
      auto err = mt.read(rmsg, 10, res);
      if (!err)
            fc_msgPrint(rmsg, res);
      else
            MCIO(err) << "BM read err:" << err.message();
      return 0;
}

int Main()
{
      return test1553();
}

namespace {

      void fc_msgPrint(M1553_T::RecvMsg_T* rmsg, size_t size)
      {
            char ch[100];
            std::string str;
            for (size_t i = 0; i < size; i++)
            {
                  str = "";
                  snprintf(ch, sizeof(ch), "bsw = 0x%04x,", rmsg[i].bsw);
                  str.append(ch);
                  snprintf(ch, sizeof(ch), "cmd1 = 0x%04x,", rmsg[i].msgBlock.cmdWord1);
                  str.append(ch);
                  snprintf(ch, sizeof(ch), "cmd2 = 0x%04x,", rmsg[i].msgBlock.cmdWord2);
                  str.append(ch);
                  str.append(" data : ");
                  for (size_t j = 0; j < 32; ++j)
                  {
                        snprintf(ch, sizeof(ch), "%04x ", rmsg[i].msgBlock.dataBlk[j]);
                        str.append(ch);
                  }
                  MCIO(log) << str;
            }
      }

      void fc_msgPrint(const std::vector<uint8_t>& buf)
      {
            char ch[100];
            std::string str;

            auto wordBuf = M1553_T::toWord(buf);

            for (const auto& val: wordBuf)
            {
                  snprintf(ch, 100, "%04x ", val);
                  str.append(ch);
            }
            MCIO(log) <<"data : "<< str;
      }
}

/** 系统固定头文件 */
#include <Rasl/rasl.hpp>
#include <DataUploader/DataUploader.hpp>
#include "StaticVariable.h"
#include "rasl-dpd/user.hpp"
#include "UserChannels.rasi"
#include "DataCollect.hpp"
/** 系统固定头文件 */
//#define MC_APPNAME "M1553-TEST"
#include <Rasl/rasl.hpp>

namespace {

      using namespace Kiyun::LowerComputer;
    using namespace Kiyun::LowerComputer::Rasl;
    using namespace Kiyun::LowerComputer::Rasl::Frame;
    using namespace Kiyun::LowerComputer::Rasl::Device;   //通道设备命名空间
    using namespace Kiyun::LowerComputer::DataUploader;   //数据上传命名空间
    using namespace Kiyun::Channel;
    using namespace Kiyun::DataCollect;                   //数据采集接口命名空间
    using namespace Dpdp;                                 //协议命名空间
      
      using namespace std;
      using namespace Mince::LowerComputer::Rasl;
      using namespace Mince::LowerComputer::Rasl::Frame;
      using namespace Mince::LowerComputer::Rasl::Device;
      void fc_msgPrint(M1553_T::RecvMsg_T* rmsg, size_t size);
      void fc_msgPrint(const std::vector<uint8_t>& buf);
}

int test1553() 
{

      MCIO(log) << "-------------1553 TEST-----------------";
      if (!mt.isValid()) {
            MCIO(err) << "bm is inValid...exit";
            return -1;
      }
      if (!dsp.isValid()) {
            MCIO(err) << "dsp is inValid...exit";
            return -1;
      }

      uint16_t outData[32] = {0};
      for (int i = 0; i < 32; i++)
            outData[i] = 0x1234 + i;

      //BC to RT
      bc0.write(outData, 32);

      //RT to BC
      outData[0] = 0x4321;
      rt5.write(outData, 32);

      //RT to RT
      outData[0] = 0x2134;
      rt2.write(outData, 32);

      //执行消息
      dsp.write(0);
      dsp.write(1);
      dsp.write(2);


      //延时保证消息已处理
      Timer_T::delay(0.1);

      dsp.write(0, false);
      Timer_T::delay(1);

      if (!dsp.isRunning())
           MCIO(log) << "bc stoped...";
      else
           MCIO(log) << "bc is running...";

      uint32_t isRunning = 1;
      while (isRunning) {
           isRunning = dsp.isRunning();
      }
      printf("BC stopped.\n");

      bc0.intRead([&](uint16_t * buf, size_t size,Error_T err)->bool {
           MCIO(log) << "-----------------------bc intRead:" << (int)buf[0];
           return true;
      });

      rt2.intRead([&](uint16_t * buf, size_t size, Error_T err)->bool {
           MCIO(log) << "-----------------------rt intRead:" << (int)buf[0];
           return true;
      });

      mt.intRead([&](uint16_t * buf, size_t size, Error_T err)->bool {
           MCIO(log) << "------------------------mt intRead:" << (int)buf[0];
           return true;
      });
      
      return 0;
}

int Main()
{
      return test1553();
}

namespace {

      void fc_msgPrint(M1553_T::RecvMsg_T* rmsg, size_t size)
      {
            char ch[100];
            std::string str;
            for (size_t i = 0; i < size; i++)
            {
                  str = "";
                  snprintf(ch, sizeof(ch), "bsw = 0x%04x,", rmsg[i].bsw);
                  str.append(ch);
                  snprintf(ch, sizeof(ch), "cmd1 = 0x%04x,", rmsg[i].msgBlock.cmdWord1);
                  str.append(ch);
                  snprintf(ch, sizeof(ch), "cmd2 = 0x%04x,", rmsg[i].msgBlock.cmdWord2);
                  str.append(ch);
                  str.append(" data : ");
                  for (size_t j = 0; j < 32; ++j)
                  {
                        snprintf(ch, sizeof(ch), "%04x ", rmsg[i].msgBlock.dataBlk[j]);
                        str.append(ch);
                  }
                  MCIO(log) << str;
            }
      }

      void fc_msgPrint(const std::vector<uint8_t>& buf)
      {
            char ch[100];
            std::string str;

            auto wordBuf = M1553_T::toWord(buf);

            for (const auto& val: wordBuf)
            {
                  snprintf(ch, 100, "%04x ", val);
                  str.append(ch);
            }
            MCIO(log) <<"data : "<< str;
      }
}

/** 系统固定头文件 */
#include <Rasl/rasl.hpp>
#include <DataUploader/DataUploader.hpp>
#include "StaticVariable.h"
#include "rasl-dpd/user.hpp"
#include "UserChannels.rasi"
#include "DataCollect.hpp"
/** 系统固定头文件 */

//用户测试代码需要新增的头文件

namespace{
    using namespace Kiyun::LowerComputer;
    using namespace Kiyun::LowerComputer::Rasl;
    using namespace Kiyun::LowerComputer::Rasl::Frame;
    using namespace Kiyun::LowerComputer::Rasl::Device;   //通道设备命名空间
    using namespace Kiyun::LowerComputer::DataUploader;   //数据上传命名空间
    using namespace Kiyun::Channel;
    using namespace Kiyun::DataCollect;                   //数据采集接口命名空间
    using namespace Dpdp;                                 //协议命名空间
    const size_t fc_inBufSize = 1024;  
    //本地变量、本地函数声明
    //Os::Semaphore_T f_exitSem;
}
extern "C"

int minceMain() {
    MCIO(out) << "----------M429_TEST---------";

    uint32_t inBuf[fc_inBufSize + 1];
    uint32_t outBuf[25];
    const uint16_t c_outBufSize = sizeof(outBuf) / sizeof(outBuf[0]);
    for (int i = 0; i < (int)c_outBufSize; i++)
        outBuf[i] = i;
    Error_T err = Error_T();

    outBuf[0] = 0x54030201;
    outBuf[1] = 0x2177;
    outBuf[2] = 0xffff;
    outBuf[3] = 0xffffff;
    outBuf[4] = 0xffffffff;
    if (!CH_429S_1.isValid()) {
        MCIO(err) << "channel is InValid";
        return -1;
    }
    //同步写
    err = CH_429S_1.write(outBuf, 5);
    if (err)
        MCIO(err) << "error when write  : " << err.message();
    else
        MCIO(log) << "Written " << c_outBufSize << " Is Over...";

    for (int i =0 ;i< 5;++i)
    {
        //同步读
        uint16_t readSize = 1;
        err = CH_429D_1.read(inBuf, readSize);
        if (!err) {
            std::string str;
            char ch[100];
            for (int i = 0; i < (int)readSize; i++)
            {
                snprintf(ch, sizeof(ch), "0x%x ", inBuf[i]);
                str.append(ch);
            }
            MCIO(log) << "ch0 sync read :" << str;
        }
        else
            MCIO(log) << "No " << readSize << " data to Read ,Read TimeOut ...";
    }
    
    return 0;
}

/** 系统固定头文件 */
#include <Rasl/rasl.hpp>
#include <DataUploader/DataUploader.hpp>
#include "StaticVariable.h"
#include "rasl-dpd/user.hpp"
#include "UserChannels.rasi"
#include "DataCollect.hpp"
/** 系统固定头文件 */

//用户测试代码需要新增的头文件

namespace{
    using namespace Kiyun::LowerComputer;
    using namespace Kiyun::LowerComputer::Rasl;
    using namespace Kiyun::LowerComputer::Rasl::Frame;
    using namespace Kiyun::LowerComputer::Rasl::Device;   //通道设备命名空间
    using namespace Kiyun::LowerComputer::DataUploader;   //数据上传命名空间
    using namespace Kiyun::Channel;
    using namespace Kiyun::DataCollect;                   //数据采集接口命名空间
    using namespace Dpdp;                                 //协议命名空间
    const size_t fc_inBufSize = 1024;  
    //本地变量、本地函数声明
    //Os::Semaphore_T f_exitSem;
}
extern "C"

int minceMain() {
    MCIO(out) << "----------M429_TEST---------";

    uint32_t inBuf[fc_inBufSize + 1];
    uint32_t outBuf[25];
    const uint16_t c_outBufSize = sizeof(outBuf) / sizeof(outBuf[0]);
    for (int i = 0; i < (int)c_outBufSize; i++)
        outBuf[i] = i;
    Error_T err = Error_T();

    outBuf[0] = 0x54030201;
    outBuf[1] = 0x2177;
    outBuf[2] = 0xffff;
    outBuf[3] = 0xffffff;
    outBuf[4] = 0xffffffff;
    if (!CH_429S_1.isValid()) {
        MCIO(err) << "channel is InValid";
        return -1;
    }
    //同步写
    err = CH_429S_1.write(outBuf, 5);
    if (err)
        MCIO(err) << "error when write  : " << err.message();
    else
        MCIO(log) << "Written " << c_outBufSize << " Is Over...";

    for (int i =0 ;i< 5;++i)
    {
        //同步读
        uint16_t readSize = 1;
        err = CH_429D_1.read(inBuf, readSize);
        if (!err) {
            std::string str;
            char ch[100];
            for (int i = 0; i < (int)readSize; i++)
            {
                snprintf(ch, sizeof(ch), "0x%x ", inBuf[i]);
                str.append(ch);
            }
            MCIO(log) << "ch0 sync read :" << str;
        }
        else
            MCIO(log) << "No " << readSize << " data to Read ,Read TimeOut ...";
    }
    
    return 0;
}

/** 系统固定头文件 */
#include <Rasl/rasl.hpp>
#include <DataUploader/DataUploader.hpp>
#include "StaticVariable.h"
#include "rasl-dpd/user.hpp"
#include "UserChannels.rasi"
#include "DataCollect.hpp"
/** 系统固定头文件 */

//用户测试代码需要新增的头文件

namespace{
    using namespace Kiyun::LowerComputer;
    using namespace Kiyun::LowerComputer::Rasl;
    using namespace Kiyun::LowerComputer::Rasl::Frame;
    using namespace Kiyun::LowerComputer::Rasl::Device;   //通道设备命名空间
    using namespace Kiyun::LowerComputer::DataUploader;   //数据上传命名空间
    using namespace Kiyun::Channel;
    using namespace Kiyun::DataCollect;                   //数据采集接口命名空间
    using namespace Dpdp;                                 //协议命名空间
    using namespace std;
    
    //本地变量、本地函数声明
    //Os::Semaphore_T f_exitSem;
}

//主函数入口
int Main()
{
    //设置全局日志属性
    KYLOG_GLOBAL().severity(Logging_T::Severity_E::TRAC_e);
    KYLOG_SCOPE("ETestRT::Main").tag("发送").tag("检查");
    KYLOG(INFO) << "Hello world, Kiyun!\n";   //可保存到日志文件
    KYIO(log) << "Hello World,Kiyun!\n";      //发送到控制台

    /*测试代码*/
    if (!fc0.isValid() || !fc1.isValid()){
        MCIO(err) << "channel is invalid...exit";
        return -1;
    }
    char sendBuf[] = "abc123";
    std::vector<uint8_t> recvBuf;

    // port0 to port1
    Error_T err = fc0.write(sendBuf, sizeof(sendBuf));
    if (err)
        MCIO(log) << "port0 write err:" << err.message();
    else
        MCIO(log) << "port0 write OK";
    Timer_T::delay(0.1);
    recvBuf.clear();
    recvBuf = fc1.read();
    if (!recvBuf.empty()){
        MCIO(log) << "port1 received :" << string(recvBuf.cbegin(), recvBuf.cend());
    }

    // port1 to port0
    sendBuf[0] = 'A';
    err = fc1.write(sendBuf, sizeof(sendBuf));
    if (err)
        MCIO(log) << "port1 write err:" << err.message();
    else
        MCIO(log) << "port1 write OK";
    Timer_T::delay(0.1);
    recvBuf.clear();
    recvBuf = fc0.read();
    if (!recvBuf.empty()){
        MCIO(log) << "port0 received :" << std::string(recvBuf.cbegin(), recvBuf.cend());
    }

    //中断读
    
     fc1.intRead([](uint8_t * buf ,size_t sz, uint32_t id, Error_T err)->bool {
            MCIO(log) << "msg_" << id << "| intRead :" << string(buf, buf + sz);
            return true;
       });
    
    MCIO(log) << "I'm listening...";
    sendBuf[0] = 'B';
    fc0.asyncWrite(sendBuf, sizeof(sendBuf), [](size_t size, Error_T err) {
        if(!err)
            MCIO(log) << "write OK";
    });
    MCIO(log) << fc0.path();
    Timer_T::delay(0.1);
    //f_exitSem.wait();
    return 0;
}

bool Exit(Os::Task_T) {
    //返回值为true,表示能中止正在运行的实时任务
    //f_exitSem.notifyOne();
    //return true;
    
    return false;  //默认情况下该实时任务不能被中止
}

参数类型

可选值

默认值

设备标识

（deviceID）

16位无符号整数

0

/** 系统固定头文件 */
#include <Rasl/rasl.hpp>
#include <DataUploader/DataUploader.hpp>
#include "StaticVariable.h"
#include "rasl-dpd/user.hpp"
#include "UserChannels.rasi"
#include "DataCollect.hpp"
/** 系统固定头文件 */

//用户测试代码需要新增的头文件

namespace{
    using namespace Kiyun::LowerComputer;
    using namespace Kiyun::LowerComputer::Rasl;
    using namespace Kiyun::LowerComputer::Rasl::Frame;
    using namespace Kiyun::LowerComputer::Rasl::Device;   //通道设备命名空间
    using namespace Kiyun::LowerComputer::DataUploader;   //数据上传命名空间
    using namespace Kiyun::Channel;
    using namespace Kiyun::DataCollect;  //数据采集接口命名空间
    using namespace Dpdp;    //协议命名空间
    using namespace std;
    using namespace Rasl::Frame;
    using Rasl::Logging_T;
    using Rasl::Os::Task_T;
    
    //本地变量、本地函数声明
    //Os::Semaphore_T f_exitSem;
    int x(0);
    int adder(void*) {
        for(int i = 0; i < 100000; ++i)
            ++x;
        return 0;
    }
}

//主函数入口
int Main()
{
    //设置全局日志属性
      KYLOG_GLOBAL().severity(Logging_T::Severity_E::DEBG_e);
    KYLOG_SCOPE("main").tag("信号相关").tag("硬件");
    KYLOG(INFO) << "Hello world, Kiyun!\n";   //可保存到日志文件
    KYIO(log) << "Hello World,Kiyun!\n";      //发送到控制台

    /*测试代码*/

    vector<Task_T> tasks;
    for(int i = 0; i < 200; ++i) {
        tasks.push_back(Task_T::spawn(adder).first);
    }
    for(auto t : tasks)
        t.wait();
        
    KYLOG(INFO) << "x : " << x;
    
    KYLOG_DEF(INFO).tag("单项标记");
    KYLOG_USE() << "Y : " << x;
    
    //f_exitSem.wait();
    return 0;
}

bool Exit(Os::Task_T) {
    //返回值为true,表示能中止正在运行的实时任务
    //f_exitSem.notifyOne();
    //return true;
    
    return false;  //默认情况下该实时任务不能被中止
}