使用C和C++进行混合编程

在做毕设过程中，用到了八个相同的传感器，传感器的通信协议都是一样的，固然直接搞八个差不多的文件来驱动传感器是没问题的，但是有一种更简洁的方式，那就是使用C++，来复用通信程序；

参考：https://zhuanlan.zhihu.com/p/115068898

环境说明

使用的单片机芯片是STM32F103C6T6；

Keil编译器版本为AC6；

Keil的配置如下：

然后是将C++源文件配对的头文件改为使用C++编译器进行编译；

源码编写

注意把main文件的后缀也改为.cpp，否则会出错；

头文件：

/*
 * @Author       : fan-pengfei 2253770787@qq.com
 * @Date         : 2023-03-07 13:43:38
 * @LastEditors  : fan-pengfei 2253770787@qq.com
 * @LastEditTime : 2023-03-07 14:41:29
 * @FilePath     : \Core\Inc\ds18b20.h
 * @Description  :
 * Copyright (c) 2023 by ${git_name_email}, All Rights Reserved.
 */
#ifndef __DS18B20_H
#define __DS18B20_H

#include "main.h"
#include "tim.h"
class DS18B20_Class
{
private:
    GPIO_TypeDef *BSP_DS18B20_PORT;
    uint16_t BSP_DS18B20_PIN;
    float *Temp_Sum;
    uint8_t LOCATION;

public:
    DS18B20_Class(GPIO_TypeDef *BSP_DS18B20_PORT, uint16_t BSP_DS18B20_PIN, uint8_t LOCATION, float *Temp_data);
    void delay_us(uint16_t us);
    GPIO_PinState DS18B20_IN(void);
    void DS18B20_OUT_1(void);
    void DS18B20_OUT_0(void);
    void DS18B20_Mode_OUT_PP(void);
    void DS18B20_Mode_IN_NP(void);
    void DS18B20_Reset(void);
    uint8_t DS18B20_Presence(void);
    uint8_t DS18B20_ReadBit(void);
    uint8_t DS18B20_ReadByte(void);
    void DS18B20_WriteByte(uint8_t dat);
    void DS18B20_ReadId(uint8_t *ds18b20_id);
    void DS18B20_SkipRom(void);
    void DS18B20_MatchRom(void);
    uint8_t Init(void);
    float DS18B20_GetTemp_SkipRom(void);
    float DS18B20_GetTemp_MatchRom(uint8_t *ds18b20_id);
    void Start_Convert(void);
    void Get_Data(uint8_t ds18b20_id[64][8]);
};

extern "C"
{
    void User_DS18B20_Init(void);
    void User_Start_Convert(void);
    void User_Get_Data(void);
}
#endif

源文件：

/*
 * @Author       : fan-pengfei 2253770787@qq.com
 * @Date         : 2023-03-07 13:43:26
 * @LastEditors  : fan-pengfei 2253770787@qq.com
 * @LastEditTime : 2023-03-07 16:41:42
 * @FilePath     : \Core\Src\ds18b20.cpp
 * @Description  :
 * Copyright (c) 2023 by ${git_name_email}, All Rights Reserved.
 */
#include "ds18b20.h"
#include "main.h"
#include "DS18B20_ID.h"
extern float Temp_Sum[64];
void DS18B20_Class::delay_us(uint16_t us)
{
    tim_delay_us(us);
    // uint32_t delay;
    // delay = (1600 * us);
    // while (delay--)
    // {
    // }
}
GPIO_PinState DS18B20_Class::DS18B20_IN(void)
{
    return HAL_GPIO_ReadPin(BSP_DS18B20_PORT, BSP_DS18B20_PIN);
}
void DS18B20_Class::DS18B20_OUT_1(void)
{
    HAL_GPIO_WritePin(BSP_DS18B20_PORT, BSP_DS18B20_PIN, GPIO_PIN_SET);
}
void DS18B20_Class::DS18B20_OUT_0(void)
{
    HAL_GPIO_WritePin(BSP_DS18B20_PORT, BSP_DS18B20_PIN, GPIO_PIN_RESET);
}
/**
 * @brief DS18B20 输出模式
 */
void DS18B20_Class::DS18B20_Mode_OUT_PP(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = BSP_DS18B20_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(BSP_DS18B20_PORT, &GPIO_InitStruct);
}
/**
 * @brief DS18B20 输入模式
 */
void DS18B20_Class::DS18B20_Mode_IN_NP(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = BSP_DS18B20_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(BSP_DS18B20_PORT, &GPIO_InitStruct);
}
/**
 * @brief 主机给从机发送复位脉冲
 */
void DS18B20_Class::DS18B20_Reset(void)
{
    DS18B20_Mode_OUT_PP(); // 主机输出
    DS18B20_OUT_0();       // 主机至少产生 480us 的低电平复位信号
    delay_us(750);
    DS18B20_OUT_1(); // 主机在产生复位信号后，需将总线拉高
    // 从机接收到主机的复位信号后，会在 15 ~ 60 us 后给主机发一个存在脉冲
    delay_us(15);
}
/**
 * @brief  检测从机给主机返回的存在脉冲
 * @return 0：成功		1：失败
 */
uint8_t DS18B20_Class::DS18B20_Presence(void)
{
    uint8_t pulse_time = 0;
    DS18B20_Mode_IN_NP();                      // 主机设为输入
    while (DS18B20_IN() && (pulse_time < 100)) // 等待低电平响应脉冲
    {
        pulse_time++;
        delay_us(1);
    }
    if (pulse_time >= 100)
    {
        return 1;
    }
    else
    {
        pulse_time = 0;
    }
    while (!(DS18B20_IN()) && pulse_time < 240)
    {
        pulse_time++;
        delay_us(1);
    }
    if (pulse_time >= 240)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
/**
 * @brief 从DS18B20读取一个bit
 */
uint8_t DS18B20_Class::DS18B20_ReadBit(void)
{
    uint8_t dat;
    DS18B20_Mode_OUT_PP(); // 读 0 和读 1 的时间至少要大于 60 us
    DS18B20_OUT_0();       // 读时间的起始：必须由主机产生 > 1us < 15us 的低电平信号
    // 这个时间非常重要，设置为 < 15，需要多次尝试；如果设置不合理，数据会直接出错
    // 参数建议设为 10 11 12，具体值要根据延时函数的执行效率测试
    delay_us(10);
    DS18B20_Mode_IN_NP(); // 设置成输入，释放总线，由外部上拉电阻将总线拉高
    if (DS18B20_IN() == 1)
    {
        dat = 1;
    }
    else
    {
        dat = 0;
    }
    delay_us(45); // 这个延时参数参考时序图
    return dat;
}
/**
 * @brief 从 DS18B20 读一个字节，低位先行
 */
uint8_t DS18B20_Class::DS18B20_ReadByte(void)
{
    uint8_t i, j, dat = 0;

    for (i = 0; i < 8; i++)
    {
        j = DS18B20_ReadBit();
        dat = (dat) | (j << i);
    }

    return dat;
}
/**
 * @brief 写一个字节到 DS18B20，低位先行
 */
void DS18B20_Class::DS18B20_WriteByte(uint8_t dat)
{
    uint8_t i, testb;
    DS18B20_Mode_OUT_PP();
    for (i = 0; i < 8; i++)
    {
        testb = dat & 0x01;
        dat = dat >> 1;
        // 写 0 和写 1 的时间至少要大于60us
        if (testb) // 当前位写 1
        {
            DS18B20_OUT_0();
            delay_us(5);     // 拉低发送写时段信号
            DS18B20_OUT_1(); // 读取电平时间保持高电平
            delay_us(65);
        }
        else // 当前位写 0
        {
            DS18B20_OUT_0(); // 拉低发送写时段信号
            delay_us(70);    // 读取电平时间保持低电平
            DS18B20_OUT_1();
            delay_us(2); // 恢复时间
        }
    }
}
/**
 * @brief  跳过匹配 DS18B20 ROM
 */
void DS18B20_Class::DS18B20_SkipRom(void)
{
    DS18B20_Reset();
    DS18B20_Presence();
    DS18B20_WriteByte(0XCC); /* 跳过 ROM */
}
/**
 * @brief  执行匹配 DS18B20 ROM
 */
void DS18B20_Class::DS18B20_MatchRom(void)
{
    DS18B20_Reset();
    DS18B20_Presence();
    DS18B20_WriteByte(0X55); /* 匹配 ROM */
}

DS18B20_Class::DS18B20_Class(GPIO_TypeDef *BSP_DS18B20_PORT, uint16_t BSP_DS18B20_PIN, uint8_t LOCATION, float *Temp_data)
{
    DS18B20_Class::BSP_DS18B20_PORT = BSP_DS18B20_PORT;
    DS18B20_Class::BSP_DS18B20_PIN = BSP_DS18B20_PIN;
    DS18B20_Class::LOCATION = LOCATION;
    DS18B20_Class::Temp_Sum = Temp_data;
}
uint8_t DS18B20_Class::Init(void)
{
    DS18B20_Mode_OUT_PP();
    DS18B20_OUT_1();
    DS18B20_Reset();
    return DS18B20_Presence();
}
/**
 * 存储的温度是16 位的带符号扩展的二进制补码形式
 * 当工作在12位分辨率时，其中5个符号位，7个整数位，4个小数位
 *
 *         |---------整数----------|-----小数 分辨率 1/(2^4)=0.0625----|
 * 低字节  | 2^3 | 2^2 | 2^1 | 2^0 | 2^(-1) | 2^(-2) | 2^(-3) | 2^(-4) |
 *
 *
 *         |-----符号位：0->正  1->负-------|-----------整数-----------|
 * 高字节  |  s  |  s  |  s  |  s  |    s   |   2^6  |   2^5  |   2^4  |
 *
 *
 * 温度 = 符号位 + 整数 + 小数*0.0625
 */
/**
 * @brief  在跳过匹配 ROM 情况下获取 DS18B20 温度值
 * @param  无
 * @retval 温度值
 */
float DS18B20_Class::DS18B20_GetTemp_SkipRom(void)
{
    uint8_t tpmsb, tplsb;
    int16_t s_tem;
    float f_tem;
    DS18B20_SkipRom();
    DS18B20_WriteByte(0X44); /* 开始转换 */
    DS18B20_SkipRom();
    DS18B20_WriteByte(0XBE); /* 读温度值 */
    tplsb = DS18B20_ReadByte();
    tpmsb = DS18B20_ReadByte();
    s_tem = tpmsb << 8;
    s_tem = s_tem | tplsb;
    if (s_tem < 0) /* 负温度 */
    {
        f_tem = (~s_tem + 1) * 0.0625f;
    }
    else
    {
        f_tem = s_tem * 0.0625f;
    }
    return f_tem;
}
/**
 * @brief  在匹配 ROM 情况下获取 DS18B20 温度值
 * @param  ds18b20_id：用于存放 DS18B20 串行号的数组的首地址
 */
void DS18B20_Class::DS18B20_ReadId(uint8_t *ds18b20_id)
{
    uint8_t uc;
    DS18B20_WriteByte(0x33); // 读取串行号
    for (uc = 0; uc < 8; uc++)
    {
        ds18b20_id[uc] = DS18B20_ReadByte();
    }
}
/**
 * @brief  在匹配 ROM 情况下获取 DS18B20 温度值
 * @param  ds18b20_id：存放 DS18B20 串行号的数组的首地址
 * @retval 温度值
 */
float DS18B20_Class::DS18B20_GetTemp_MatchRom(uint8_t *ds18b20_id)
{
    uint8_t tpmsb, tplsb, i;
    int16_t s_tem;
    float f_tem;
    DS18B20_MatchRom(); /* 匹配ROM */
    for (i = 0; i < 8; i++)
    {
        DS18B20_WriteByte(ds18b20_id[i]);
    }
    DS18B20_WriteByte(0X44); /* 开始转换 */
    DS18B20_MatchRom();      /* 匹配ROM */
    for (i = 0; i < 8; i++)
    {
        DS18B20_WriteByte(ds18b20_id[i]);
    }
    DS18B20_WriteByte(0XBE); /* 读温度值 */
    tplsb = DS18B20_ReadByte();
    tpmsb = DS18B20_ReadByte();
    s_tem = tpmsb << 8;
    s_tem = s_tem | tplsb;
    if (s_tem < 0) /* 负温度 */
    {
        f_tem = (~s_tem + 1) * 0.0625f;
    }
    else
    {
        f_tem = s_tem * 0.0625f;
    }
    return f_tem;
}
void DS18B20_Class::Start_Convert(void)
{
    DS18B20_SkipRom();
    DS18B20_WriteByte(0X44); /* 开始转换 */
}
void DS18B20_Class::Get_Data(uint8_t ds18b20_id[64][8])
{
    uint8_t tpmsb, tplsb;
    int16_t s_tem;
    float f_tem;
    for (uint8_t i = 0; i < 8; i++)
    {
        DS18B20_MatchRom(); /* 匹配ROM */
        for (uint8_t j = 0; j < 8; j++)
        {
            DS18B20_WriteByte(ds18b20_id[(LOCATION - 1) * 8 + i][j]);
        }
        DS18B20_WriteByte(0XBE); /* 读温度值 */
        tplsb = DS18B20_ReadByte();
        tpmsb = DS18B20_ReadByte();
        s_tem = tpmsb << 8;
        s_tem = s_tem | tplsb;
        if (s_tem < 0) /* 负温度 */
        {
            f_tem = (~s_tem + 1) * 0.0625f;
        }
        else
        {
            f_tem = s_tem * 0.0625f;
        }
        Temp_Sum[(LOCATION - 1) * 8 + i] = f_tem;
    }
}
float temp_data[64];
DS18B20_Class DS18B20[8] = {DS18B20_Class(D1_GPIO_Port, D1_Pin, 1, temp_data),
                            DS18B20_Class(D2_GPIO_Port, D2_Pin, 2, temp_data),
                            DS18B20_Class(D3_GPIO_Port, D3_Pin, 3, temp_data),
                            DS18B20_Class(D4_GPIO_Port, D4_Pin, 4, temp_data),
                            DS18B20_Class(D5_GPIO_Port, D5_Pin, 5, temp_data),
                            DS18B20_Class(D6_GPIO_Port, D6_Pin, 6, temp_data),
                            DS18B20_Class(D7_GPIO_Port, D7_Pin, 7, temp_data),
                            DS18B20_Class(D8_GPIO_Port, D8_Pin, 8, temp_data)};
extern "C"
{
    void User_DS18B20_Init(void)
    {
        for (int i = 0; i < 8; i++)
        {
            DS18B20[i].Init();
        }
    }
    void User_Start_Convert(void)
    {
        for (int i = 0; i < 8; i++)
        {
            DS18B20[i].Start_Convert();
        }
    }
    void User_Get_Data(void)
    {
        for (int i = 0; i < 8; i++)
        {
            DS18B20[i].Get_Data(ROM_ID);
        }
    }
}

要注意其中的extern "C"的用法；

Main中调用：

注意main文件也是cpp后缀；

void main(void)
{
    User_DS18B20_Init();
    while (1)
    {
        User_Start_Convert();
        HAL_Delay(200); // 更新速率为200ms，等待转换结束
        User_Get_Data();
        int i = 0;
        while (i < 64)
        {
            printf("temp[%d]:%.3lf\r\n", i, temp_data[i]);
            i++;
            if (i % 8 == 0)
            {
                printf("\r\n----------------------------%d\r\n", i / 8);
            }
        }
    }
}

其他

可执行文件的大小比较

实现相同功能的情况下，生成的bin文件的大小比较：

使用C编写
使用C++编写

C:

Total RO Size (Code + RO Data)	14016 (13.69kB)
Total RW Size (RW Data + ZI Data)	2040 (1.99kB)
Total ROM Size (Code + RO Data + RW Data)	14464 ( 14.13kB)

C++:

Total RO Size (Code + RO Data)	11780 (11.50kB)
Total RW Size (RW Data + ZI Data)	2864 (2.80kB)
Total ROM Size (Code + RO Data + RW Data)	12220 ( 11.93kB)

相比较而言C用的ROM比较多一些，C++用的RAM比较多一些；

可见在某些情况下，使用C++编写代码可以有效缩减代码体积，且代码更易懂；

microlib

使用C++编译的话，就没法再使用MicroLIB，因为MicroLIB为非标准的精简库，会与标准C++产生冲突；

中断服务程序

如果中断服务程序是异常的，因为stm32的中断入口矢量是按C的方式进入的，因此需要在整个文档的头部和末尾加上extern “C”{}用大括号把整个代码段扩住，这样中断就可以正常的进入了；

Cubemx

Cubemx在生成头文件中已经加入了：

#ifdef __cplusplus
extern "C" {
#endif


#ifdef __cplusplus
}
#endif

所以在不是其生成的文件中要注意extern "C"的使用；

当需要使用有C++特性的头文档时可以直接用cpp后缀，没有用到C++特性的可以C后缀也可以以CPP后缀了；

printf的实现

半主机模式是ARM的一种机制，实现将来ARM应用程序代码的输入/输出请求传送至运行着调试器的主机。例如设置使用半主机模式下的ARM应用程序，可以使用printf()和scanf()来使用主机的显示器和键盘，而不需要在ARM系统上搭配显示器和键盘。
半主机通过一组定义好的软件指令(如SVC)来实现的，这些指令在程序控制下产生异常，ARM应用程序调用半主机对应的异常处理函数，然后调试代理处理该异常。

第二段话感觉理解起来有点模糊，但是第一段还是懂它在讲什么的。一般的ARM应用程序中并不需要半主机操作，在这里为确保ARM应用程序中没有链接MicroLib的半主机相关函数，我们要取消ARM的半主机工作模式。

实现代码：

在工程中加上如下代码：

// 取消ARM的半主机工作模式
__asm(".global __use_no_semihosting"); // 用于AC6编译器
// #pragma import(__use_no_semihosting)//用于AC5编译器
FILE __stdout;
void _sys_exit(int x)
{
    x = x;
}

int fputc(int ch, FILE *f)
{
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
    return ch;
}

然后就可以愉快的使用printf打印日志了；

赏

谢谢你请我喝可乐

支付宝

微信