ST17H26 SDK中宏定义注意事项

宏定义使用很方便，但 "##" 在宏中使用时可能导致宏定义在si工程中无法跟踪，切记！

如下：

#pragma once

/* Enable C linkage for C++ Compilers: */
#if defined(__cplusplus)
extern "C" {
#endif

#define _USER_CONFIG_DEFINED_ 1 // must define this macro to make others known
#define __LOG_RT_ENABLE__ 0

product Information //
#define ID_VENDOR 0x248a // for report
#define ID_PRODUCT_BASE 0x880C
// If ID_PRODUCT left undefined, it will default to be combination of ID_PRODUCT_BASE and the USB config USB_SPEAKER_ENABLE/USB_MIC_ENABLE...
// #define ID_PRODUCT 0x8869

#define STRING_VENDOR L"Lenze"
#define STRING_PRODUCT L"BLE iSearching"
#define STRING_SERIAL L"17H26"

//#define CHIP_TYPE // CHIP_TYPE_17H26 //

#define FLOW_NO_OS 1
#define RF_FAST_MODE_1M 1

/// Clock /
#define CLOCK_SYS_TYPE CLOCK_TYPE_PLL // one of the following: CLOCK_TYPE_PLL, CLOCK_TYPE_OSC, CLOCK_TYPE_PAD, CLOCK_TYPE_ADC
#define CLOCK_SYS_CLOCK_HZ 32000000

//Extern Crystal Type///
#define CRYSTAL_TYPE XTAL_12M // extern 16M crystal

Moudule Enable
#define MODULE_ADC_ENABLE 0

#define LED_USE_PWM 0

/// IO Setting /
/*Device Name Selection GP4 and GP5*/
#define GPIO4_FUNC AS_GPIO
#define GPIO4_OUTPUT_ENABLE 0
#define GPIO4_INPUT_ENABLE 1
#define PULL_WAKEUP_SRC_GPIO4 PM_PIN_PULLDOWN_100K

#define GPIO5_FUNC AS_GPIO
#define GPIO5_OUTPUT_ENABLE 0
#define GPIO5_INPUT_ENABLE 1
#define PULL_WAKEUP_SRC_GPIO5 PM_PIN_PULLDOWN_100K

/*LED GP7*/
#if(LED_USE_PWM)
#define GPIO7_FUNC AS_PWM
#define GPIO7_OUTPUT_ENABLE 0
#define PULL_WAKEUP_SRC_GPIO7 PM_PIN_UP_DOWN_FLOAT
#else
#define GPIO7_FUNC AS_GPIO
#define GPIO7_OUTPUT_ENABLE 1
#define GPIO7_INPUT_ENABLE 0
#define PULL_WAKEUP_SRC_GPIO7 PM_PIN_UP_DOWN_FLOAT
#endif

/*Buzzer GP10*/
#define GPIO10_FUNC AS_PWM
#define GPIO10_OUTPUT_ENABLE 0
#define PULL_WAKEUP_SRC_GPIO7 PM_PIN_UP_DOWN_FLOAT

/*Button: BTN1-GP18 BTN2-GP17 BTN3-GP22*/
#define GPIO17_FUNC AS_GPIO
#define GPIO17_OUTPUT_ENABLE 0
#define GPIO17_INPUT_ENABLE 1
#define PULL_WAKEUP_SRC_GPIO17 PM_PIN_PULLDOWN_100K

#define GPIO18_FUNC AS_GPIO
#define GPIO18_OUTPUT_ENABLE 0
#define GPIO18_INPUT_ENABLE 1
#define PULL_WAKEUP_SRC_GPIO18 PM_PIN_PULLDOWN_100K

#define GPIO22_FUNC AS_GPIO
#define GPIO22_OUTPUT_ENABLE 0
#define GPIO22_INPUT_ENABLE 1
#define PULL_WAKEUP_SRC_GPIO22 PM_PIN_PULLDOWN_100K

/*Select Hardware_Switch Or Software_Switch*/
#define GPIO23_FUNC AS_GPIO
#define GPIO22_OUTPUT_ENABLE 0
#define GPIO22_INPUT_ENABLE 1
#define PULL_WAKEUP_SRC_GPIO22 PM_PIN_PULLUP_10K

#ifndef DEBUG_FROM_FLASH
#define DEBUG_FROM_FLASH 0
#endif

#if(DEBUG_FROM_FLASH) // firmware in flash (flash max size decided by flash type)
#define CFG_ADR_MAC 0xf000 // this address must be out of code space
#define CFG_FREQUENCY_OFFSET 0xf008 // this address must be out of code space

// gpio init , for compiler here

#else // firmware in otp(otp max size is (0x3fff - 20))

// gpio init , for compiler here
#define MSDO_INPUT_ENABLE 0
#define MSDI_INPUT_ENABLE 0
#define MCLK_INPUT_ENABLE 0
#define MSCN_INPUT_ENABLE 0
#endif

/// ADC /
#if(MODULE_ADC_ENABLE)

#define ADC_CHNM_ANA_INPUT ADC_CHN_GP18 //others parameters (ADC_CHN_GP17 ADC_CHN_GP18 ADC_CHN_GP22 ADC_CHN_GP23)
#define ADC_CHNM_REF_SRC ADC_REF_1P3V //others parameters (ADC_REF_1P3V ADC_REF_VDDH)

#endif

/// RAM&OTP Optimization /
/*Disable interrupt for 8263_remote application*/
#define ENABLE_INTERRUPT 0

#if ENABLE_INTERRUPT
#define FLASH_OP_DISABLE_IRQ 1 /*1 Means flash operation needs to disable IRQ*/
#define ANALOG_OP_DISABLE_IRQ 1
#define KEYSCAN_OP_DISABLE_IRQ 1
#define RING_BUF_OP_DISABLE_IRQ 1
#define BLT_LL_OP_DISABLE_IRQ 1

#else
#define FLASH_OP_DISABLE_IRQ 0
#define ANALOG_OP_DISABLE_IRQ 0
#define KEYSCAN_OP_DISABLE_IRQ 0
#define RING_BUF_OP_DISABLE_IRQ 0
#define BLT_LL_OP_DISABLE_IRQ 0
#endif

/*Define low resource cost event call back functions*/
#define LOW_COST_EVENT_CB_MODE 1

/// RAMCODE optimize

/// set default

#include "../common/default_config.h"

/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)
}
#endif

#pragma once

#include "../common/types.h"
#include "../common/bit.h"
#include "../common/utility.h"
#include "../mcu/compiler.h"
#include "../mcu/register.h"
#include "gpio_default_17H26.h"

enum
{
GPIO_GROUP0 = 0x000,
GPIO_GROUP1 = 0x100,
GPIO_GROUP2 = 0x200,
GPIO_GROUP3 = 0x300,
GPIO_GROUP4 = 0x400,
GPIO_GROUP_MASK = 0x700,
};

enum
{
GPIO_GP0 = 0x000 | BIT(0),
GPIO_GP1 = 0x000 | BIT(1),
GPIO_GP2 = 0x000 | BIT(2),
GPIO_GP3 = 0x000 | BIT(3),
GPIO_GP4 = 0x000 | BIT(4),
GPIO_GP5 = 0x000 | BIT(5),
GPIO_GP6 = 0x000 | BIT(6),
GPIO_GP7 = 0x000 | BIT(7),

GPIO_PULLUPDN_COUNT = 33,
GPIO_MAX_COUNT = 38,
};

#define reg_gpio_in(i) REG_ADDR8(0x580+((i>>8)<<3))
#define reg_gpio_ie(i) REG_ADDR8(0x581+((i>>8)<<3))
#define reg_gpio_oen(i) REG_ADDR8(0x582+((i>>8)<<3))
#define reg_gpio_out(i) REG_ADDR8(0x583+((i>>8)<<3))
#define reg_gpio_pol(i) REG_ADDR8(0x584+((i>>8)<<3))
#define reg_gpio_ds(i) REG_ADDR8(0x585+((i>>8)<<3))
#define reg_gpio_gpio_func(i) REG_ADDR8(0x586+((i>>8)<<3))
#define reg_gpio_irq_en(i) REG_ADDR8(0x587+((i>>8)<<3))
#define reg_gpio_2risc0(i) REG_ADDR8(0x5a8+(i>>8))
#define reg_gpio_2risc1(i) REG_ADDR8(0x5b0+(i>>8))

static inline int gpio_is_output_en(u32 pin)
{
return !BM_IS_SET(reg_gpio_oen(pin), pin & 0xff);
}

static inline int gpio_is_input_en(u32 pin)
{
return BM_IS_SET(reg_gpio_ie(pin), pin & 0xff);
}

static inline void gpio_set_output_en(u32 pin, u32 value)
{
u8 bit = pin & 0xff;
if(!value)
{
BM_SET(reg_gpio_oen(pin), bit);
}
else
{
BM_CLR(reg_gpio_oen(pin), bit);
}
}

static inline void gpio_set_input_en(u32 pin, u32 value)
{
u8 bit = pin & 0xff;
if(value)
{
BM_SET(reg_gpio_ie(pin), bit);
}
else
{
BM_CLR(reg_gpio_ie(pin), bit);
}
}

static inline void gpio_set_data_strength(u32 pin, u32 value){
u8 bit = pin & 0xff;
if(value)
{
BM_SET(reg_gpio_ds(pin), bit);
}
else
{
BM_CLR(reg_gpio_ds(pin), bit);
}
}

static inline void gpio_en_interrupt(u32 pin)
{
u8 bit = pin & 0xff;
BM_SET(reg_gpio_irq_en(pin), bit);
}

static inline void gpio_set_interrupt(u32 pin, u32 falling)
{
u8 bit = pin & 0xff;
BM_SET(reg_gpio_irq_en(pin), bit);
if(falling)
{
BM_SET(reg_gpio_pol(pin), bit);
}
else
{
BM_CLR(reg_gpio_pol(pin), bit);
}
}

static inline void gpio_set_interrupt_pol(u32 pin, u32 falling)
{
u8 bit = pin & 0xff;
if(falling)
{
BM_SET(reg_gpio_pol(pin), bit);
}
else
{
BM_CLR(reg_gpio_pol(pin), bit);
}
}

static inline void gpio_clr_interrupt(u32 pin)
{
u8 bit = pin & 0xff;
BM_CLR(reg_gpio_irq_en(pin), bit);
}

static inline void gpio_write(u32 pin, u32 value)
{
u8 bit = pin & 0xff;
if(value)
{
BM_SET(reg_gpio_out(pin), bit);
}
else
{
BM_CLR(reg_gpio_out(pin), bit);
}
}

static inline u32 gpio_read(u32 pin)
{
return BM_IS_SET(reg_gpio_in(pin), pin & 0xff);
}

static inline u32 gpio_read_cache(u32 pin, u8 *p)
{
return p[pin>>8] & (pin & 0xff);
}

static inline void gpio_read_all(u8 *p)
{
p[0] = REG_ADDR8(0x580);
p[1] = REG_ADDR8(0x588);
p[2] = REG_ADDR8(0x590);
p[3] = REG_ADDR8(0x598);
p[4] = REG_ADDR8(0x5a0);
}

static inline void gpio_core_wakeup_enable_all (int en)
{
#if 0
if (en) {
BM_SET(reg_gpio_wakeup_en, FLD_GPIO_WAKEUP_EN);
}
else {
BM_CLR(reg_gpio_wakeup_en, FLD_GPIO_WAKEUP_EN);
}
#endif
}

//level = 1 : high wakeup
static inline void gpio_enable_wakeup_pin(u32 pin, u32 level, int en)
{
u8 bit = pin & 0xff;

if(level)
{
BM_CLR(reg_gpio_pol(pin), bit);
}
else
{
BM_SET(reg_gpio_pol(pin), bit);
}

if (en)
{
BM_SET(reg_gpio_irq_en(pin), bit);
}
else
{
BM_CLR(reg_gpio_irq_en(pin), bit);
}
}

/*******************************************************************************

*******************************************************************************/
#define GPIO_VALUE(type,pol,n) (GPIO##n##_##type==(pol)?(1<<(n&0x07)):0)
#define GPIO_FUNC_VALUE(type,pol,func,pos) (func##_##type==(pol)?(1<<pos):0)

static inline void gpio_init(void)
{
reg_gpio_group0_ie = (u8)GPIO_REG_VALUE_GROUP0(INPUT_ENABLE,1);
reg_gpio_group0_oen = (u8)GPIO_REG_VALUE_GROUP0(OUTPUT_ENABLE,0);
reg_gpio_group0_out = (u8)GPIO_REG_VALUE_GROUP0(DATA_OUT,1);
reg_gpio_group0_ds = (u8)GPIO_REG_VALUE_GROUP0(DATA_STRENGTH,1);
reg_gpio_group0_func = (u8)GPIO_REG_VALUE_GROUP0(FUNC,0);

reg_gpio_group1_ie = (u8)GPIO_REG_VALUE_GROUP1(INPUT_ENABLE,1);
reg_gpio_group1_oen = (u8)GPIO_REG_VALUE_GROUP1(OUTPUT_ENABLE,0);
reg_gpio_group1_out = (u8)GPIO_REG_VALUE_GROUP1(DATA_OUT,1);
reg_gpio_group1_ds = (u8)GPIO_REG_VALUE_GROUP1(DATA_STRENGTH,1);
reg_gpio_group1_func = (u8)GPIO_REG_VALUE_GROUP1(FUNC,0);

reg_gpio_group2_ie = (u8)GPIO_REG_VALUE_GROUP2(INPUT_ENABLE,1);
reg_gpio_group2_oen = (u8)GPIO_REG_VALUE_GROUP2(OUTPUT_ENABLE,0);
reg_gpio_group2_out = (u8)GPIO_REG_VALUE_GROUP2(DATA_OUT,1);
reg_gpio_group2_ds = (u8)GPIO_REG_VALUE_GROUP2(DATA_STRENGTH,1);
reg_gpio_group2_func = (u8)GPIO_REG_VALUE_GROUP2(FUNC,0);

reg_gpio_group3_ie = (u8)GPIO_REG_VALUE_GROUP3(INPUT_ENABLE,1);
reg_gpio_group3_oen = (u8)GPIO_REG_VALUE_GROUP3(OUTPUT_ENABLE,0);
reg_gpio_group3_out = (u8)GPIO_REG_VALUE_GROUP3(DATA_OUT,1);
reg_gpio_group3_ds = (u8)GPIO_REG_VALUE_GROUP3(DATA_STRENGTH,1);

reg_gpio_group4_ie = (u8)GPIO_REG_VALUE_GROUP4(INPUT_ENABLE,1);
reg_gpio_group4_oen = (u8)GPIO_REG_VALUE_GROUP4(OUTPUT_ENABLE,0);
reg_gpio_group4_out = (u8)GPIO_REG_VALUE_GROUP4(DATA_OUT,1);
reg_gpio_group4_ds = (u8)GPIO_REG_VALUE_GROUP4(DATA_STRENGTH,1);
reg_gpio_group4_func = (u8)GPIO_REG_VALUE_GROUP4(FUNC,0);

analog_write (0x08, PULL_WAKEUP_SRC_GPIO17 |
(PULL_WAKEUP_SRC_GPIO18<<2) |
(PULL_WAKEUP_SRC_GPIO19<<4) |
(PULL_WAKEUP_SRC_GPIO20<<6));

analog_write (0x09, PULL_WAKEUP_SRC_GPIO21 |
(PULL_WAKEUP_SRC_GPIO22<<2) |
(PULL_WAKEUP_SRC_GPIO23<<4) |
(PULL_WAKEUP_SRC_GPIO24<<6));

analog_write (0x28, (PULL_WAKEUP_SRC_GPIO32==PM_PIN_PULLDOWN_100K) |
((PULL_WAKEUP_SRC_GPIO0==PM_PIN_PULLDOWN_100K)<<1) |
((PULL_WAKEUP_SRC_GPIO1==PM_PIN_PULLDOWN_100K)<<2) |
((PULL_WAKEUP_SRC_GPIO2==PM_PIN_PULLDOWN_100K)<<3) |
((PULL_WAKEUP_SRC_GPIO3==PM_PIN_PULLDOWN_100K)<<4) |
((PULL_WAKEUP_SRC_GPIO4==PM_PIN_PULLDOWN_100K)<<5) |
((PULL_WAKEUP_SRC_GPIO5==PM_PIN_PULLDOWN_100K)<<6) |
((PULL_WAKEUP_SRC_GPIO6==PM_PIN_PULLDOWN_100K)<<7));

analog_write (0x29, (PULL_WAKEUP_SRC_GPIO7==PM_PIN_PULLDOWN_100K) |
((PULL_WAKEUP_SRC_GPIO8==PM_PIN_PULLDOWN_100K)<<1) |
((PULL_WAKEUP_SRC_GPIO9==PM_PIN_PULLDOWN_100K)<<2) |
((PULL_WAKEUP_SRC_GPIO10==PM_PIN_PULLDOWN_100K)<<3) |
((PULL_WAKEUP_SRC_GPIO11==PM_PIN_PULLDOWN_100K)<<4) |
((PULL_WAKEUP_SRC_GPIO12==PM_PIN_PULLDOWN_100K)<<5) |
((PULL_WAKEUP_SRC_GPIO13==PM_PIN_PULLDOWN_100K)<<6) |
((PULL_WAKEUP_SRC_GPIO14==PM_PIN_PULLDOWN_100K)<<7));

analog_write (0x2a, (PULL_WAKEUP_SRC_GPIO15==PM_PIN_PULLDOWN_100K) |
((PULL_WAKEUP_SRC_GPIO16==PM_PIN_PULLDOWN_100K)<<1) |
(PULL_WAKEUP_SRC_GPIO26<<2) |
(PULL_WAKEUP_SRC_GPIO27<<4) |
(PULL_WAKEUP_SRC_GPIO31<<6));

#if (__BLE__DEBUG_GPIO__)
/* Set DEBUG GPIO functions as output gpio*/
BM_SET(reg_gpio_gpio_func(DBG_PIN0), DBG_PIN0 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN1), DBG_PIN1 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN2), DBG_PIN2 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN3), DBG_PIN3 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN4), DBG_PIN4 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN5), DBG_PIN5 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN6), DBG_PIN6 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN7), DBG_PIN7 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN8), DBG_PIN8 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN9), DBG_PIN9 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN10), DBG_PIN10 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN11), DBG_PIN11 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN12), DBG_PIN12 & 0xff);
BM_SET(reg_gpio_gpio_func(DBG_PIN13), DBG_PIN13 & 0xff);

gpio_set_input_en(DBG_PIN0, 0);
gpio_set_input_en(DBG_PIN1, 0);
gpio_set_input_en(DBG_PIN2, 0);
gpio_set_input_en(DBG_PIN3, 0);
gpio_set_input_en(DBG_PIN4, 0);
gpio_set_input_en(DBG_PIN5, 0);
gpio_set_input_en(DBG_PIN6, 0);
gpio_set_input_en(DBG_PIN7, 0);
gpio_set_input_en(DBG_PIN8, 0);
gpio_set_input_en(DBG_PIN9, 0);
gpio_set_input_en(DBG_PIN10, 0);
gpio_set_input_en(DBG_PIN11, 0);
gpio_set_input_en(DBG_PIN12, 0);
gpio_set_input_en(DBG_PIN13, 0);

gpio_set_output_en(DBG_PIN0, 1);
gpio_set_output_en(DBG_PIN1, 1);
gpio_set_output_en(DBG_PIN2, 1);
gpio_set_output_en(DBG_PIN3, 1);
gpio_set_output_en(DBG_PIN4, 1);
gpio_set_output_en(DBG_PIN5, 1);
gpio_set_output_en(DBG_PIN6, 1);
gpio_set_output_en(DBG_PIN7, 1);
gpio_set_output_en(DBG_PIN8, 1);
gpio_set_output_en(DBG_PIN9, 1);
gpio_set_output_en(DBG_PIN10, 1);
gpio_set_output_en(DBG_PIN11, 1);
gpio_set_output_en(DBG_PIN12, 1);
gpio_set_output_en(DBG_PIN13, 1);
#endif
}

static inline void gpio_set_func(u32 pin, u32 func)
{
u8 bit = pin & 0xff;
if(func == AS_GPIO)
{
BM_SET(reg_gpio_gpio_func(pin), bit);
return;
}
else
{
BM_CLR(reg_gpio_gpio_func(pin), bit);
}

}

#if (__BLE__DEBUG_GPIO__)
#define BLE_DBG_GPIO_WRITE(pin, v) do{ if(pin){gpio_write(pin, v);}}while(0);
#else
#define BLE_DBG_GPIO_WRITE(pin, v)
#endif

extern void gpio_setup_up_down_resistor(u32 gpio, u32 up_down);

#define GPIO_VALUE(type,pol,n) (GPIO##n##_##type==(pol)?(1<<(n&0x07)):0)
#define GPIO_FUNC_VALUE(type,pol,func,pos) (func##_##type==(pol)?(1<<pos):0)

#define GPIO4_FUNC AS_GPIO
#define GPIO4_OUTPUT_ENABLE 0
#define GPIO4_INPUT_ENABLE 1
#define PULL_WAKEUP_SRC_GPIO4 PM_PIN_PULLDOWN_100K

比如：GPIO4_OUTPUT_ENABLE 其实在函数中使用了，但由于使用了##，导致si工程中搜索不到。

ST17H26 SDK中宏定义注意事项相关推荐

如何用C语言改变宏定义的大小,C语言中宏定义使用的小细节
C语言中宏定义使用的小细节 #pragma#pragma 预处理指令详解在所有的预处理指令中,#Pragma 指令可能是最复杂的了,它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作.#p ...
C/C++编程笔记：浅析Ｃ语言中宏定义的使用，知识点全解
宏定义是用一个标识符来表示一个字符串,在宏调用中将用该字符串代替宏名.给程序员提供了便利,使程序更加清晰,便于阅读和理解,进一步提高了程序的运行效率,对于嵌入式系统而言,为了能达到性能要求,宏是一种很 ...
libev中ev_loop结构体中宏定义的理解
libev源代码由于有各种宏定义,十分让人费解,作者这么写确实使得代码很简练,但也给读者的阅读带来了巨大的麻烦,下面将分析下ev_loop这个结构体的定义,加深对作者代码简化的理解,先上代码: str ...
c语言中宏定义的字符替换#define M（x，y，z） x*y+z
C语言中宏定义的字符替换问题例子: 在c语言中定义如下宏 #define M(x,y,z) x*y+z 给定如下程序 #include<stdio.h> #include<stdl ...
verilog 定义位宽为1的_Verilog中宏定义位宽带来的问题
Verilog 中宏定义位宽带来的问题宏定义在 C 语言程序中的使用司空见惯,他的好处就在于可以大大提高代码的可读性和可移植性.而在 verilog 中,也支持这个语法,在很多开源代码中也都能看到 ...
C语言宏定义##连接符和#符的使用及其它宏定义注意事项
C语言中如何使用宏C(和C++)中的宏(Macro)属于编译器预处理的范畴,属于编译期概念(而非运行期概念).下面对常遇到的宏的使用问题做了简单总结. 关于#和## 在C语言的宏中,#的功能是将其后面 ...
C#中宏定义#define、预处理#if #else #endif的使用
C#中预处理的使用: 预处理指令并不会被编译为执行代码中的指令,但使用预处理指令可以选择编译程序中的哪部分代码.一般在调试代码时或在发布不同功能等级的软件版本中使用. 需要特别注意的是,宏定义必须在C ...
C语言中宏定义和函数的取舍
要写好C语言,漂亮的宏定义是非常重要的.宏定义可以帮助我们防止出错,提高代码的可移植性和可读性等. 在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定 ...
java中宏定义,宏定义的使用
C中的宏分为两类,对象宏(object-like macro)和函数宏(function-like macro). 预定义宏: 1.预定义宏的行为是由编译器指定的. 2.前后双下杠的一般都是预定义. ...

ST17H26 SDK中宏定义注意事项

ST17H26 SDK中宏定义注意事项相关推荐

最新文章

热门文章