关于医疗器械的算法、协议开发（五）

已于 2022-07-05 23:28:37 修改
阅读量175 收藏
点赞数
分类专栏： 笔记 工作笔记 文章标签： 算法
于 2022-07-05 23:08:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AN15778423590/article/details/125630036
版权

监控芯片接收内容：

#include "ProtocolManager.h"
#include "ProtocolHeartBeat.h"
#include "ProtocolCommunicate.h"
#include "ProtocolAlarm.h"
#include "ProtocolWirelessRawData.h"
#include "ProtocolSpo2.h"

ProtocolManager * ProtocolManager::_instance = NULL;

ProtocolManager::ProtocolManager()
    :_circleBuf(2048)
{
    _allProtocolObjs.clear();
#if USING_CMD_LIST
    _cmds.clear();
#endif
    _proDrv = NULL;
}

ProtocolManager::~ProtocolManager()
{

}

int ProtocolManager::registerProtocol(ProtocolObj *obj)
{
    int ret = 0;

    if (!obj)
    {
        return 1;
    }
    list<ProtocolObj *>::iterator it = _allProtocolObjs.begin();
    for (;it != _allProtocolObjs.end(); it++)
    {
        if (*it == obj)
        {
            ret = 1;
            return ret;
        }
    }

    obj->init();
    _allProtocolObjs.push_back(obj);
    return ret;
}

int ProtocolManager::unregisterProtocol(ProtocolObj *obj)
{
    int ret = 1;
    if (!obj)
    {
        return ret;
    }
    list<ProtocolObj *>::iterator it = _allProtocolObjs.begin();
    for (;it != _allProtocolObjs.end(); it++)
    {
        if (*it == obj)
        {
            ret = 0;
            _allProtocolObjs.erase(it);
            obj->deinit();
            return ret;
        }
    }
    return ret;
}

int ProtocolManager::loopRun()
{
    if (_proDrv)
        _proDrv->loopRun();
    list<ProtocolObj *>::iterator it = _allProtocolObjs.begin();
    for (;it != _allProtocolObjs.end(); it++)
    {
        ProtocolObj *obj = *it;
        if (obj)
        {
            obj->loopRun();
        }
    }

    handleProtocol();
#if USING_CMD_LIST
    handleSendCmds();
#endif
    return 0;
}

void ProtocolManager::init()
{
    ProtocolHeartBeat *pHeartBeat = new ProtocolHeartBeat(this);
    registerProtocol(pHeartBeat);

    ProtocolAlarm *pAlarm = new ProtocolAlarm(this);
    registerProtocol(pAlarm);

    ProtocolWirelessRawData *pWireless = new ProtocolWirelessRawData(this);
    registerProtocol(pWireless);

    ProtocolSpo2 *pSpo2 = new ProtocolSpo2(this);
    registerProtocol(pSpo2);

    ProtocolCommunicate *pCommunicate = new ProtocolCommunicate();
    registerProDrv(pCommunicate);
}

void ProtocolManager::registerProDrv(ProtocolDrv *drv)
{
    if (drv)
    {
        drv->init();
        _proDrv = drv;
    }
}

int ProtocolManager::checkData(uint8_t *buf, int len)
{
    int sum = 0;
    for (int i = 0; i < len; i++)
    {
        sum += buf[i];
    }

    return sum;
}

#if 0
void ProtocolManager::handleProtocol()
{
    int loopCnt = 0;
    while (_circleBuf.length() >= 7)
    {
        loopCnt++;
        if (loopCnt >= 50)
        {
            break;//防止出现死循环
        }
        uint8_t startCh = _circleBuf[0];
        if (startCh == 0xAA)
        {
            uint8_t h1 = _circleBuf[1];
            uint8_t h2 = _circleBuf[2];
            uint8_t h3 = _circleBuf[3];
            uint8_t h4 = _circleBuf[4];
            uint16_t len = (h3 << 8) | h4;
            //这里存在一个风险，如果数据长度即 _circleBuf[3]_circleBuf[4]数据错位那么就会导致我们buff存满永远处理不了数据
            //例如我们循环队列长度是2048 但是len解析出来是4096 那么就会出现错误
            //所以我们这里给buffer一个阀值
            //如果这包协议中len的长度超出我们的这个值就将数据推出buffer
            if (len > 500)
            {
                _circleBuf.popData();
                continue;
            }
            if (_circleBuf.length() < len + 7)
            {
                break;
            }
            else
            {
                uint8_t *buf = new uint8_t[len + 7];
                for (int i = 0; i < len + 7; i++)
                {
                    buf[i] = _circleBuf.popData();
                }
                int checkRcv = (buf[len + 5] << 8) | buf[len + 6];
                int checkRes = checkData(&buf[5], len);
                if (checkRcv != checkRes)
                {
                    log_info("Rcv an invalid packet\n");
                }
                else
                {
                    uint16_t cmd = (buf[1] << 8) | buf[2];
                    list<ProtocolObj *>::iterator it = _allProtocolObjs.begin();
                    for (; it != _allProtocolObjs.end(); it++)
                    {
                        ProtocolObj *obj = *it;
                        if (obj)
                        {
                            if (obj->getId() == cmd)
                            {
                                obj->handleRcvData(&buf[5], len);
                            }
                        }
                    }
                }
                delete [] buf;
            }
        }
        else
        {
            //无效的头部信息
            _circleBuf.popData();
        }
    }
}

#endif


void ProtocolManager::handleProtocol()
{
    int loopCnt = 0;
    while (_circleBuf.length() >= 7)
    {
        loopCnt++;
        if (loopCnt >= 50)
        {
            break;//防止出现死循环
        }
        uint8_t startCh1 = _circleBuf[0];
        uint8_t startCh2 = _circleBuf[1];
        if (startCh1 == 0xAA && startCh2 == 0xFF)
        {
            uint8_t h3 = _circleBuf[3];
            uint8_t h4 = _circleBuf[4];
            uint16_t len = (h3 << 8) | h4;
            //这里存在一个风险，如果数据长度即 _circleBuf[3]_circleBuf[4]数据错位那么就会导致我们buff存满永远处理不了数据
            //例如我们循环队列长度是2048 但是len解析出来是4096 那么就会出现错误
            //所以我们这里给buffer一个阀值
            //如果这包协议中len的长度超出我们的这个值就将数据推出buffer
            if (len > 500)
            {
                _circleBuf.popData();
                continue;
            }
            if (_circleBuf.length() < len + 7)
            {
                break;
            }
            else
            {
                uint8_t *buf = new uint8_t[len + 7];
                for (int i = 0; i < len + 7; i++)
                {
                    //buf[i] = _circleBuf.popData();
                    buf[i] = _circleBuf[i];
                }
                int checkRcv = (buf[len + 5] << 8) | buf[len + 6];
                int checkRes = checkData(&buf[5], len);
                if (checkRcv != checkRes)
                {
                    _circleBuf.popData();
                    log_info("Rcv an invalid packet\n");
                }
                else
                {
                    for (int i = 0; i < len + 7; i++)
                    {
                        buf[i] = _circleBuf.popData();
                    }
                    uint8_t cmd = buf[2];
                    list<ProtocolObj *>::iterator it = _allProtocolObjs.begin();
                    for (; it != _allProtocolObjs.end(); it++)
                    {
                        ProtocolObj *obj = *it;
                        if (obj)
                        {
                            if (obj->getId() == cmd)
                            {
                                obj->handleRcvData(&buf[5], len);
                            }
                        }
                    }
                }
                delete [] buf;
            }
        }
        else
        {
            //无效的头部信息
            _circleBuf.popData();
        }
    }
}

int ProtocolManager::sendData(uint8_t *buf, uint16_t len, uint8_t cmd)
{
    if (buf)
    {
        uint16_t sum = 0;
        uint16_t sendLen = 1 + 2 + 2 + len + 2; //查看协议文档
        uint8_t *sendBuf = new uint8_t[sendLen];
        sendBuf[0] = 0xAA;
        sendBuf[1] = 0xFF;
        sendBuf[2] = cmd;

        sendBuf[3] = (len & 0xFF00)>>8;
        sendBuf[4] = (len & 0xFF);

        for (int i = 0; i < len; i++)
        {
            sendBuf[5+ i] = buf[i];
            sum += buf[i];
        }

        sendBuf[5 + len] = (sum & 0xFF00)>>8;
        sendBuf[5 + len + 1] = (sum & 0xFF);
#if 0
        if (_proDrv && _proDrv->isReady())
            _proDrv->sendData(sendBuf, sendLen);

        delete [] sendBuf;
#endif

#if USING_CMD_LIST
        SendCmd *cmd = new SendCmd;
        cmd->cmd = sendBuf;
        cmd->len = sendLen;
        _cmds.push_back(cmd);
#else
        if (_proDrv && _proDrv->isReady())
            _proDrv->sendData(sendBuf, sendLen);

        delete [] sendBuf;
#endif
        return len;
    }
    return 0;
}

#if USING_CMD_LIST
void ProtocolManager::handleSendCmds()
{
    while (!_cmds.empty())
    {
        list<SendCmd *>::iterator it = _cmds.begin();
        _cmds.erase(it);
        SendCmd *cmd = *it;
        if (_proDrv)
            _proDrv->sendData(cmd->cmd, cmd->len);
        delete cmd->cmd;
        delete cmd;
    }
}
#endif

int ProtocolManager::rcvData(uint8_t *buf, uint16_t len)
{
    int ret = 0;
    if (buf)
    {
        for (int i = 0; i < len; i++)
        {
            _circleBuf.pushData(buf[i]);
        }
        ret = len;
    }
    return ret;
}

协议接收数据

void ProtocolManager::handleProtocol()
{
    int loopCnt = 0;
    while (_circleBuf.length() >= 7)
    {
        loopCnt++;
        if (loopCnt >= 50)
        {
            break;//防止出现死循环
        }
        uint8_t startCh1 = _circleBuf[0];
        uint8_t startCh2 = _circleBuf[1];
        if (startCh1 == 0xAA && startCh2 == 0xFF)
        {
            uint8_t h3 = _circleBuf[3];
            uint8_t h4 = _circleBuf[4];
            uint16_t len = (h3 << 8) | h4;
            //这里存在一个风险，如果数据长度即 _circleBuf[3]_circleBuf[4]数据错位那么就会导致我们buff存满永远处理不了数据
            //例如我们循环队列长度是2048 但是len解析出来是4096 那么就会出现错误
            //所以我们这里给buffer一个阀值
            //如果这包协议中len的长度超出我们的这个值就将数据推出buffer
            if (len > 500)
            {
                _circleBuf.popData();
                continue;
            }
            if (_circleBuf.length() < len + 7)
            {
                break;
            }
            else
            {
                uint8_t *buf = new uint8_t[len + 7];
                for (int i = 0; i < len + 7; i++)
                {
                    //buf[i] = _circleBuf.popData();
                    buf[i] = _circleBuf[i];
                }
                int checkRcv = (buf[len + 5] << 8) | buf[len + 6];
                int checkRes = checkData(&buf[5], len);
                if (checkRcv != checkRes)
                {
                    _circleBuf.popData();
                    log_info("Rcv an invalid packet\n");
                }
                else
                {
                    for (int i = 0; i < len + 7; i++)
                    {
                        buf[i] = _circleBuf.popData();
                    }
                    uint8_t cmd = buf[2];
                    list<ProtocolObj *>::iterator it = _allProtocolObjs.begin();
                    for (; it != _allProtocolObjs.end(); it++)
                    {
                        ProtocolObj *obj = *it;
                        if (obj)
                        {
                            if (obj->getId() == cmd)
                            {
                                obj->handleRcvData(&buf[5], len);
                            }
                        }
                    }
                }
                delete [] buf;
            }
        }
        else
        {
            //无效的头部信息
            _circleBuf.popData();
        }
    }
}

协议发送数据

int ProtocolManager::sendData(uint8_t *buf, uint16_t len, uint8_t cmd)
{
    if (buf)
    {
        uint16_t sum = 0;
        uint16_t sendLen = 1 + 2 + 2 + len + 2; //查看协议文档
        uint8_t *sendBuf = new uint8_t[sendLen];
        sendBuf[0] = 0xAA;
        sendBuf[1] = 0xFF;
        sendBuf[2] = cmd;

        sendBuf[3] = (len & 0xFF00)>>8;
        sendBuf[4] = (len & 0xFF);

        for (int i = 0; i < len; i++)
        {
            sendBuf[5+ i] = buf[i];
            sum += buf[i];
        }

        sendBuf[5 + len] = (sum & 0xFF00)>>8;
        sendBuf[5 + len + 1] = (sum & 0xFF);
#if 0
        if (_proDrv && _proDrv->isReady())
            _proDrv->sendData(sendBuf, sendLen);

        delete [] sendBuf;
#endif

#if USING_CMD_LIST
        SendCmd *cmd = new SendCmd;
        cmd->cmd = sendBuf;
        cmd->len = sendLen;
        _cmds.push_back(cmd);
#else
        if (_proDrv && _proDrv->isReady())
            _proDrv->sendData(sendBuf, sendLen);

        delete [] sendBuf;
#endif
        return len;
    }
    return 0;
}

应用层的串口发送接口：

int ProtocolCommunicate::init()
{
    MX_USART1_UART_Init();
    ready();
    ProtocolCommunicate::_instance = this;
    HAL_UART_Receive_IT(&huart1, _comRcvBuf, 1);
    return 0;
}

/*************************************************************
  *Brief:发送数据,中断中不能调用此函数，否则发送数据会错乱
  *Arguments:
  *Returns:
  *Author:xiaoyetongxue
  *Date:2021
****************************************************************/
int ProtocolCommunicate::sendData(uint8_t *buf, uint16_t len)
{
    if (buf)
    {
        HAL_UART_Transmit(&huart1, buf, len, 100);
        //for (int i = 0; i < len; i++)
        //{
           //HAL_UART_Transmit(&huart1, &buf[i], 1, 100);
           //HAL_Delay(1);
           //波特率是115200 每次发送一个字节需要时间是69us
           //cpu频率是24M每条指令大概是4ns 69*1000/4 = 170000
           //这里等待每个字节发送完毕,延迟大概80us，如果使用HAL_Delay(1);
           //1ms的时间对于系统来说太长了
//           for (int j =0 ;j < 20000; j++)
//           {

//           }
        //}
        return len;
    }
    return -1;
}

***心电发送到主控芯片***
int ProtocolHeartBeat::deinit()
{
    return 0;
}

int ProtocolHeartBeat::loopRun()
{
    sendHeartBeat();
    if (_timeOut)
    {
        //副cpu已经死机了要开始重启
    }
    return 0;
}

#if 1
void ProtocolHeartBeat::sendHeartBeat()
{
    static int cnt = 0;
    int tick = HAL_GetTick();
    if (tick - cnt > 1000)
    {
        cnt = tick;
        uint8_t buf[1] = { 0x00 };
        sendData(buf, 0, PROTOCOL_ID_HEART_BEAT);
    }
}
#endif


***血氧应用***
int SpO2::rcvData(uint8_t *buf, int len)
{
    return SysProtocol->sendData(buf, len, PROTOCOL_ID_SPO2_RAW_DATA);
}
小叶同学~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C程序员从校园到职场》第8章 算法和协议
rmyd01的博客
07-07 125
第8章　算法和协议 算法（Algorithm），是程序的灵魂。著名计算机科学家、图灵奖获得者沃思曾提出过一个公式：数据结构+算法=程序。可见，算法在程序中占有非常重要的地位。在实际的开发工作中，不管是有意设计或是无意为之，我们几乎随时在和算法打交道。小到定义一个变量，大到编写一个函数，这些都是算法的实现过程。 在实际的软件开发项目中，经常要实现多个模块之间的通信，这就需要大家约定好相互之间的通...
关于医疗器械的算法、协议开发（二）
AN15778423590的博客
05-18 247
接着上一篇，这一篇主要是编写关于与模块接收数据及算法解析后的传输过程： 1.首先是接收模块检测的数据进行解析 2.进行解析整理并按照协议算法进行发送（前提需要串口驱动） 3.开始进行解析的数据应用层处理 接收模块数据且在应用层解析处理 #include "SpO2DrvRawData.h" #include "SpO2DrvSatex.h" #include "main.h" #include <stdint.h> #include <stdlib.h> SpO2DrvRawD
医疗软件产品核心算法部分说明--转载截取
qq_37716917的博客
01-27 2825
各方资料汇总说明 核心算法概述 算法类型： 公认成熟算法：公开文献专利标准、原理简单明确、上市超过四年且无不良时间。公认成熟算法名称、原理、用途，全新算法列明名称、原理、用途，并提供验证资料。 全新算法：源自科学研究和临床数据。 例如： 软件使用mpeg-4作为存储动态影像的核心存储算法，系统通过采集卡从摄像头获取图像数据，然后通过mpeg-4动态图像专家组图像压缩算法对数字图像进行压缩，并将压缩后的数字图像数据以avi的方式保存影像文件中，供后续操作使用。系统在需要调取前面保存的动态影像数
医疗器械c#上位机开发指引教程
ansuhao2407的博客
04-20 1026
此教程面向的读者：对医疗器械上位机编程有兴趣，或者急需了解医疗器械（尿常规、血液分析、生化、心电、B超等医疗下位仪器）的编程流程、编程细节的程序员。 1、得到仪器协议 当我们需要与医疗器械等下位机数据交互时，我们需要知道它用的是哪种协议，这样才能得到我们想要的数据。当然，没有协议，我们也能解析，在此步骤的弟三段中我将提到。得到协议后，我们将得到重要的几样东西，比如波特率...
CFDA 医疗器械软件 软件生存周期过程
12-09
软件生存周期过程 CFDA 医疗器械软件
医疗器械软件注册申报-核心算法
就这样吧
03-11 5546
依据软件设计规格（SDS）和用户说明书列明核心算法的名称、原理、用途和类型。核心算法包括后处理算法和人工智能算法，其中后处理算法通常会改变原始医学图像或数据，包括但不限于压缩、分割、配准融合、三维重建、量化分析和异常识别；人工智能算法通常基于数据库进行分析处理，包括但不限于模式识别、神经网络和专家系统。类型是指公认成熟算法（公开文献专利标准、原理简单明确、上市超过四年且无不良事件）或全新算法（源...
dcm医疗图片
07-12
1. DICOM标准：DICOM标准是由北美放射学会（Radiological Society of North America, RSNA）和国家电子医疗器械制造商协会（National Electrical Manufacturers Association, NEMA）共同制定的，旨在规范医疗成像...
射频识别医疗设备轻量级相互认证研究.pdf
12-26
在医疗领域，RFID可以用于医疗器械追踪、病人监护等，极大地提高了医疗工作的效率和准确性。然而，RFID技术的安全性是其广泛应用的重要考量因素，尤其是面对低成本标签时，由于计算能力有限，更需要设计出轻量级的...
TTCAN协议在智能照明控制系统中的应用研究.pdf
09-13
此外，该研究还提及了TTCAN协议在汽车、航空、安防、工程机械、医疗器械、楼宇自动化等其他领域的广泛应用，显示出TTCAN协议在多领域的适应性和优越性。通过深入研究和优化TTCAN协议及其在智能照明控制中的具体实现...
针对医疗行业中近距离无线通信技术的应用与安全分析.pdf
09-02
此外，Zigbee还能支持设备间的双向通信，使得医疗器械能够自动配对和交互，简化操作流程。然而，Zigbee的安全性也值得关注，如未经授权的设备可能窃听或干扰通信，数据加密的强度直接影响到数据安全。 2. 蓝牙技术 ...
基于msp430单片机的温度pid算法设计.doc
最新发布
07-06
1.msp430单片机：msp430是一款低功耗、低成本的单片机，广泛应用于工业自动化、家电、医疗器械等领域。msp430具有丰富的外设资源，包括adc、dac、uart、spi等，使其非常适合各种应用场景。 2.位置式pid算法：pid...
医疗器械软件测试相关
cailiao11的博客
07-19 5331
1、构成： 医疗器械方面的软件一般都是嵌入式的，分上位机和下位机。 上位机就是纯软件操作系统，用于控制下位机的，下位机大多指硬件，也包括嵌入式软件。 2、软件生存周期过程 软件生存周期过程是要根据国家相关文件YY∕T 0664-2008 形成一套软件生存周期的软件开发过程文档；另外质量部门形成的相关控制程序规范也会成为过程的执行和记录要素；在整个周期过程中始终贯穿风险评估的环节。 3、法规注册 （1）国内法规注册要求 ①参考文档： 《医疗器械生产质量管理规范附录独立软件》 《GB T 2500.
关于软件的核心，莫被算法和使用技术完全忽悠了
liougehooa的专栏
09-17 245
关于软件的核心，莫被算法和技术完全忽悠了 很多人开发多年，对技术一腔热忱，甚至一些企业，居心叵测的企业，打着“招”最聪明的程序员进行“欺骗”和“误导”，在网络上和乃至社会形成了一种风气，这种风气已经严重影响到软件的开发。 计算机自诞生以来，经历了语言上的成熟，我们逐渐把眼光转向了解决实际问题的问题空间，特别是面向对象的语言诞生以来，因为对象的粒度十分恰当好处，一方面我们很容易把一些语言上的...
数字图像处理--平滑滤波
AN15778423590的博客
03-28 4645
1.相关知识 今天介绍平滑滤波的一些知识！ 相关知识：均值模板和中值滤波 例如，3X3均值模板(取图像相邻区域的像素求和取平均代替中心像素，更高次类似) [ 1 1 1 1 1 1 1 1 1] 然后说说中值滤波，还是以3X3来说，将3X3区域内的像素按大小值进行排列，取中间的值代替模板中心的值。 好了，基础说完了，来实际操作吧！ 2.内容代码 2.1 选择一副具有大小尺寸的物体图像，分别选择 3×3，7×7，25×25 等平均模板进行均值滤波模糊处理，并对不同尺寸的滤波器模板操作后的图像进行比较。 参考代
基于STM32的IAP开发
AN15778423590的博客
07-29 3607
公司在开发一款智能眼镜，使用NXP系列芯片作为主控芯片，蓝牙连接，总体来说不是很复杂。在发给客户测试的时候发现了一些问题，需要重新更新程序。这在开发人员看来只要两三下的事情，在客户手里可能就是一个巨麻烦的事情。所以决定给设备添加在线升级功能，通过蓝牙将新的固件更新到主控芯片里，而bootloader就是OTA中不可或缺的一部分。部分内容是在网上转载其他资料的，如冒犯，速告知，立马删除。 不需要拆机就能对产品进行固件升级是很多人想要的效果，不仅方便而且节省精力和成本。那么如何完成这项工作呢?接下来所介绍的Bo
关于基于STM32中SPWM的软件实现以及注意点
AN15778423590的博客
08-11 3509
这几天在做一个光伏采集电压的项目，这里面就运用到了H式逆变桥，而用到逆变桥，就必然会使用到SPWM来调制IGBT，再通过低通滤波使该电路产生一个正弦波。而这个项目的重点就是这个SPWM的调控，如何调制适合的电压来是逆变桥输出正弦波，也是重中之重。 在我这几天的收集资料以及思考里，我想到了很多实现spwm的方法，像用两个定时器来实现，一个产生波形，另一个捕获比较产生占空比。这些都是实践之后可以实现的了，但后来了解了项目的需求之后，我最终决定使用定时器1中断来输出SPWM,原理也和以上方法一样，这个我就不多说了
STM32_Debug 使用ST-Link以及J-Link进行调试出现Error:Flash Download Failed-“Cortex-M3“ 解决方案
AN15778423590的博客
07-25 2716
在Debug窗口依次注意以下几个点： 1.选择与主控芯片相配套的芯片 2.选择ST-Link Debugger—-此处注意该页面最下面一行可不更改（亲测有效） 3.接上图点击进入Setting，依次选择 4.进入Flash Download 注意同样选中与主控芯片相配套的flash类型，出现Error:Flash Download Failed-“Cortex-M3” 问题，多由于该处没有选择正确 注：此处本人也存在疑惑，若为“Med-density”与芯片选型配套，在此基础上再进行类型选择时，就
USB工作学习笔记（一）
AN15778423590的博客
11-06 2582
关于USB协议的学习工作笔记
条件编译#ifdef的妙用详解_透彻
AN15778423590的博客
09-19 1900
本文主要介绍c语言中条件编译相关的预编译指令，包括 #define、#undef、#ifdef、#ifndef、#if、#elif、#else、#endif、defined。 #define 定义一个预处理宏 #undef 取消宏的定义 #if 编译预处理中的条件命令，相当于C语法中的if语句 #ifdef 判断某个宏是否被定义，若已定义，执行随后的语句 #ifndef 与#if

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值