所有的努力，不过是为了“定位BUG更容易，构建编码更快速”？

辛昕 · 发表于2017-11-16 18:08

所有的努力，不过是为了“定位BUG更容易，构建编码更快速”？ [复制链接]

本帖最后由辛昕于 2017-11-18 13:56 编辑

   已完成部分：
   01.寄存器映射、外设驱动：BSP一包到底，提供读写总线足以，不配置，不通用。

   前阵子，我花了好几个小时，终于把（王宜怀）基于飞思卡尔K60系列这本书里关于（单片机）软件代码模块化这部分的内容看完，并写了一个很粗糙的笔记。作为我想解决关于自己此前纠结，反复了很久的诸如：如何写一个“通用的单片机编程框架” 之类的问题的起点。但这本书看完后，包括我花了大量时间重新浏览了一下我在eeworld这几年的所有帖子之后，我竟然惊讶的发现——我所纠结的，没想到竟是出奇的简单，三句话足以说完：
   说到底，就是为了BUG容易改，代码写的快......
   然后该怎么办呢？
   良好架构！优秀框架！分层！重构！代码风格！加强测试！全局变量函数@#%#&$^&%$^.......    回想过去五六年我在这上面是摸爬滚打，盖世神功没学会，反惹一身骚，疲惫不堪。

   因此，我当时有点失望，也没有太大动力继续去正式地写这个帖子，直到最近挖板块的老帖，挖到16年@zmsxhy 的一个帖子，刚刚我在写这个贴的草稿之前，我看了一下他的个人资料，发现他不是我想象的学生党毕业党，只是他似乎是硬件为主，但对软件似乎也很好奇很用功，让我有点扶额的是，从他发的帖子标题来看，以及他看到我的回复后留下的热切回复来看，我断定：
   他一定，也在纠结我曾经纠结了四五年的事情，于是，我突然决定，正儿八经开始写这个帖子。
   我只希望：少一次类似的，其实很无谓的折腾。

此内容由EEWORLD论坛网友辛昕原创，如需转载或用于商业用途需征得作者同意并注明出处

辛昕 · 发表于2017-11-16 18:09

本帖最后由辛昕于 2017-11-16 18:18 编辑

   闲话少说，为了避免以往的没边没际的废话。我先简单说自己的结论：
   1. 所谓的良好结构，优秀框架，或者什么什么风格，思想，真的可以有助于定位BUG，快速编码，然后......
      说实话，我觉得这话听着特别不靠谱，跟大街上说报考学车，30天拿证什么的差不多。
      ——最后你要是真的30天拿证，那你一定度过了生不如死的30天或者天生骨骼精奇，而和这个驾校其实没什么关系，还不是一样被骂的狗血淋头，一样怀疑人生。
   2.单片机程序，或者说我们碰到的、我们自己的写出来的，通常，都不会太大的程序而言（自己编码的行数，通常在10K到20K以内）。所以什么设计模式什么框架，可能根本毫无用武之地，你每次折腾来折腾去，玩得最多的可能还是变量数组，函数。听着最高大上的可能也只是所谓模块而已。

   而我发的那么多帖子，说来说去，讨论的只不过是很小的一个层面的模块封装：单片机底层寄存器映射。          另外就是，对于单片机应用，经常是驱动和应用都不大，基本没有分开讨论的价值，所以，单片机程序往往有代码规模类似的驱动和“上层应用”组合，所以我也考虑这个层面的功能模块的封装。

lcofjp · 发表于2017-11-16 18:23

本帖最后由 lcofjp 于 2017-11-16 18:32 编辑

教主继续，搬小板凳听课。

mzb2012 · 发表于2017-11-16 19:18

都是干货，期待继续；其实我也很好奇，高手都是如何写代码的，首先就是如何减少全局变量的使用。哎吆，我去，我的代码，全局编量就是我的屠龙宝刀，真想自废武功啊！

yang_alex · 发表于2017-11-16 19:46

有时感觉减少全局变量和模块化就是鸡和鸡蛋的关系。共同的目的就是减少耦合，减少犯错误的几率。

辛昕 · 发表于2017-11-16 21:02

lcofjp 发表于 2017-11-16 18:23
教主继续，搬小板凳听课。

这个可能会写的有点慢。
慢慢期待吧。
可以提出你们感兴趣的问题，这个事情涉及很多东西，我有时也不知道从何说起，要慢慢写草稿慢慢整理。

白丁 · 发表于2017-11-16 21:25

搬个小板凳学习

shihuntaotie · 发表于2017-11-16 21:53

搬小板凳，等待上课

sblpp · 发表于2017-11-16 22:01

写的多了自然就成了。这些都是表象，重要的是解决问题的思想，比如用面向对象的思想去封装去实现。
玩植物大战僵尸、梦想小镇等游戏的时候，就想想如果自己写的话该用什么样的方法来实现...

zmsxhy · 发表于2017-11-17 09:18

一直在等这个东西啊

le062 · 发表于2017-11-17 09:28

面向对象没问题，但是代价比linux/windows代价高。比如下面这个按键扫描程序，利用中断回调驱动，可以监测单击事件、双击事件、长击事件。但是代码是要与底层中断模块相配合使用的，在A单片机能用，换用B单片机后，由于外部中断模块不同，可能就不是最佳设计了。

#ifndef __VSF_KEY_H_INCLUDED__
#define __VSF_KEY_H_INCLUDED__
#define VSF_KEY_SCANF_INTERVAL 5 // ms
#define VSF_KEY_SCANF_VALID_CNT 5 // max 8
#define VSF_KEY_DCLICK_INTERVAL 300
#define VSF_KEY_SCANF_VALID_MASK ((uint8_t)(~(0xff << VSF_KEY_SCANF_VALID_CNT)))
struct vsf_key_t
{
struct vsfsm_t *report_sm;
uint32_t single_click_event;
uint32_t long_click_event;
uint32_t double_click_event;
uint16_t long_click_threshold_ms; // min: (VSF_KEY_SCANF_VALID_CNT + 1) * VSF_KEY_SCANF_INTERVAL
uint16_t pull_up_en : 1;
uint16_t pull_down_en : 1;
uint16_t valid_level : 1;
uint16_t key_port : 5;
uint16_t key_pin : 8;
// private
uint8_t value : 1;
uint8_t : 7;
uint8_t scanf_code;
uint16_t scanf_cnt;
struct vsfsm_t sm;
uint32_t last_realease_tick;
};
void vsf_key_init(struct vsf_key_t *key);
void vsf_key_fini(struct vsf_key_t *key);
#define vsf_key_get(key) (key->value)
#endif // __VSF_KEY_H_INCLUDED__

复制代码

#include "vsf.h"
#include "vsf_key.h"
#define KEY_EINT_TRIGGER (VSFSM_EVT_USER_LOCAL + 1)
static void key_callback(void *param)
{
struct vsf_key_t *key = param;
vsfhal_eint_disable(key->key_port | (key->key_pin << 4));
vsfsm_post_evt_pending(&key->sm, KEY_EINT_TRIGGER);
}
static struct vsfsm_state_t *key_handler(struct vsfsm_t *sm, vsfsm_evt_t evt)
{
struct vsf_key_t *key = sm->user_data;
uint32_t tick;
uint8_t value;
switch (evt)
{
case VSFSM_EVT_INIT:
vsfhal_gpio_init(key->key_port);
vsfhal_eint_init(key->key_port | (key->key_pin << 4));
vsfhal_eint_config(key->key_port | (key->key_pin << 4),
EINT_ONFALL | EINT_ONRISE, 0, key, key_callback);
if (key->pull_up_en)
{
vsfhal_gpio_config(key->key_port, 0x1 << key->key_pin, 0,
0x1 << key->key_pin, 0);
}
else if (key->pull_down_en)
{
vsfhal_gpio_config(key->key_port, 0x1 << key->key_pin, 0,
0x1 << key->key_pin, 0x1 << key->key_pin);
}
else
{
vsfhal_gpio_config(key->key_port, 0x1 << key->key_pin, 0, 0, 0);
}
if (vsfhal_gpio_get(key->key_port, 1 << key->key_pin))
{
key->value = 1;
}
else
{
key->value = 0;
}
vsfhal_eint_enable(key->key_port | (key->key_pin << 4));
break;
case KEY_EINT_TRIGGER:
key->scanf_code = vsfhal_gpio_get(key->key_port, 1 << key->key_pin) ? 1 : 0;
key->scanf_cnt = 1;
vsftimer_create(sm, VSF_KEY_SCANF_INTERVAL, 1, VSFSM_EVT_DELAY_DONE);
break;
case VSFSM_EVT_DELAY_DONE:
key->scanf_code <<= 1;
key->scanf_code |= vsfhal_gpio_get(key->key_port, 1 << key->key_pin) ? 1 : 0;
if (key->scanf_cnt < 0xffff)
key->scanf_cnt++;
if (key->scanf_cnt == VSF_KEY_SCANF_VALID_CNT)
{
if (((key->scanf_code & VSF_KEY_SCANF_VALID_MASK) == 0) ||
((key->scanf_code & VSF_KEY_SCANF_VALID_MASK) == VSF_KEY_SCANF_VALID_MASK))
{
value = key->scanf_code & 0x1;
if (key->value == value)
{
goto stop_scan;
}
tick = vsfhal_tickclk_get_count();
key->value = value;
if (key->single_click_event != 0)
{
vsfsm_post_evt_pending(key->report_sm , key->single_click_event);
}
if ((key->double_click_event != 0) && (key->value != key->valid_level)) // double click check
{
if (key->last_realease_tick + VSF_KEY_DCLICK_INTERVAL >= tick)
vsfsm_post_evt_pending(key->report_sm , key->double_click_event);
key->last_realease_tick = tick;
}
else if ((key->long_click_event != 0) && (key->value == key->valid_level)) // long click check
{
goto goon_scan;
}
goto stop_scan;
}
else
{
key->scanf_cnt--;
}
}
else if (key->scanf_cnt > VSF_KEY_SCANF_VALID_CNT)
{
if ((key->scanf_code & 0x1) != key->valid_level)
{
vsfsm_post_evt_pending(sm, KEY_EINT_TRIGGER);
break;
}
else if (key->scanf_cnt == key->long_click_threshold_ms / VSF_KEY_SCANF_INTERVAL)
{
vsfsm_post_evt_pending(key->report_sm, key->long_click_event);
goto stop_scan;
}
}
goon_scan:
vsftimer_create(sm, VSF_KEY_SCANF_INTERVAL, 1, VSFSM_EVT_DELAY_DONE);
break;
stop_scan:
vsfhal_eint_enable(key->key_port | (key->key_pin << 4));
break;
default:
break;
}
return NULL;
}
void vsf_key_init(struct vsf_key_t *key)
{
key->sm.init_state.evt_handler = key_handler;
key->sm.user_data = key;
vsfsm_init(&key->sm);
}
void vsf_key_fini(struct vsf_key_t *key)
{
nuc505_eint_disable(key->key_port | (key->key_pin << 4));
vsfsm_fini(&key->sm);
}

复制代码

辛昕 · 发表于2017-11-17 09:44

le062 发表于 2017-11-17 09:28
面向对象没问题，但是代价比linux/windows代价高。比如下面这个按键扫描程序，利用中断回调驱动，可以监测 ...

所以，接下来你就会看到，我倾向BSP一包打到底。
管他中断还是按键，全在一起。换一个板子换一个MCU我换一套BSP

wateras1 · 发表于2017-11-17 10:36

看到这篇帖子，我也想说几句，（王宜怀）基于飞思卡尔K60系列这本书我记得12年左右一个论坛送了我一本(现在压箱底了)，当时我正好在研究架构设计，希望将来做一名资深架构师（中间也买了几本架构设计的书），刚开始时觉得如获至宝，感觉自己学了后可以"纵横江湖"，后面运用到实践项目上，真的感觉如鸡肋。工作这些年，对于楼主说的所有努力不过是为了更好的定位问题和解决问题，我是认可的。从过去在现在我一直觉得一个工程师最核心的杀手锏就是"一剑封喉"的定位和解决问题能力。所谓项目开发无非就是遇到bug时的压抑状态和解决bug后的狂喜状态反复切换的过程。
我一直很反感的就是那些以为上了什么RTOS或者什么架构就bug少很多的人，这个就有点类似我考过了驾照，就不可能成为马路杀手一样。我现在编程一直在锻炼我的逻辑思维能力，而不是什么架构牛逼，编程很漂亮什么的。

这些年走过来，我真的很庆幸自己坚持下来了，有时我回想过去，都很佩服自己，如果人生还可以在回转一次，我真的不一定能坚持下去，至少按照我现在的心态。

我实习时第一份工作去的小公司，第一天上午给我看的公司规章，还没看完，下午就让我画PCB改电路，我很多同学去的公司都还在打杂都不涉及研发类工作，去的大点的公司的直接去培训去了。没同事帮，我亚历山大。为了证明自己的价值，我每天最早到公司（五点多起，北京冬天天都是黑的，用手机当电筒照路），最晚出公司，每天晚上回去还自主干到两点多，最疯狂时，连续加班三个多月，每天睡几个小时，最后把自己加进了医院，连续打了三天点滴，发烧40度，这个应该是我工作中最激情四射的时光，每天都是神农尝百草一样反复验证分析解决问题，没经验就的从失败中反复建立起来。
后面几份工作也是救火，要不就是整个部门的核心人员都离职，不知情下，直接接手把整个项目抗下来，要不就是从没做过的项目，短期内，最快的一次是入职第二天就开始设计协议栈（从没做过的，跨行找的工作，三份协议文档，每份几千页，搞得每天晚上都加班看协议，第二天写代码，就是这样的极限工作，我第一次，真的感觉到了自己的后背汗是凉的，现在我不会去找这类工作了）。这些工作，如果按照一般人说去架构设计，老板早把你干掉了，很多工作说白了就是前人挖了很多坑，解决不了了走人了，你要背锅，老板要的就是立刻马上把bug都干掉，能把这条破船的漏洞全部给我补上，让船开到岸边，一船人不要淹死到大海中，到了岸边，你可以重新设计一条船。最近公司来了一个架构师，水平真的很水，听过他对他那个小组布置的任务就知道。破船不补，要搞新船，优化什么架构，之前mqtt服务器至少可以保证一个月挂一次，按照他的要求改，一天挂三次（幸亏我不是他那个组的，不然就得干上了）。可能最后也和之前一个架构师自己主动走人，又留下一个烂摊子，如果换作我来搞，根本就不会这样（分工问题，虽然都会，但是只做一小部分，得益于多年一个项目都自己干的好处），不过现在在一家国企，我已经不像从前那样喜欢出风头，给多少钱干多少活，也活得自在。～～～～～～～～～～～～

最后说了那么多废话，其实我就想说，不管你采用什么架构，什么编码规范，你的目的都是为了将来能快速定位问题和解决问题，如果不能达到这个目的，对于老板来说，就是垃圾，没任何价值，再说，现在的老板有多少真正懂技术，你说的他能真正懂？他要的就是快点立刻把Bug给解决，不然走人（我boss的口头禅）。

辛昕 · 发表于2017-11-17 11:40

wateras1 发表于 2017-11-17 10:36
看到这篇帖子，我也想说几句，（王宜怀）基于飞思卡尔K60系列这本书我记得12年左右一个论坛送了我一本(现在 ...

说的非常好。
刚开始骑士君，大概是在一年多以前还是两年前，那时候就听说了他的思路，内心佩服之余，却也觉得，实在是太粗暴简单。
谁成想，搞了半天，今天我坚定地站到了他这一边。

当然——我真心不是让你不爱学习不爱看书不爱好好写代码，我没那个意思，如果有人误会了我真的无语。
我和骑士君的意思是一样的：不要以为漂亮代码可以拯救你，要记住那句话：软件的世界里没有银弹。

辛昕 · 发表于2017-11-17 18:29

回到第一个问题：底层寄存器映射

简单地说，就是类似这种代码（以最简单的GPIO为例）

long ReadGPIO(unsigned long ulPort, unsigned char ucPins)
{
switch(ulPort)
{
case(GPIOA0_BASE):Num_H = 0;break;
case(GPIOA1_BASE):Num_H = 1;break;
case(GPIOA2_BASE):Num_H = 2;break;
case(GPIOA3_BASE):Num_H = 3;break;
case(GPIOA4_BASE):Num_H = 4;break;
}
Num_Pins = ucPins;
for(Num_L=0;;Num_L++)
{
Num_Pins = Num_Pins/2;
if(Num_Pins==0)
break;
}
Num = Num_H*8+Num_L; // 相当于 gpiox * 8 + pinx
return (HWREG(ulPort + (GPIO_O_GPIO_DATA + (ucPins << 2)))&(1<< (Num % 8)))>>(Num % 8);
}

复制代码

freebsder · 发表于2017-11-17 19:29

本帖最后由 freebsder 于 2017-11-17 19:37 编辑

一帮只听别人吹起过"设计"的人陷在自己的井里互相吹捧天不过如此点大，可笑至极。
私下乱扯本也所谓，也没闲情逸致狗拿耗子，可是放在公共区域里误导人，没见过世面挨怼了也就受着吧。

辛昕 · 发表于2017-11-18 01:22

下午下班的时候，我想了很久，始终没想到关于这个话题，怎么切入，最后决定回到原点：
我当初都见过一些什么东西，这些东西让我觉得很震惊，或者很恶心。
于是，我想起了三个东西：
1.Arduino的底层配置文件；
2.以前MDK4的时候，有个引脚，外设配置文件（当时我还没想起叫什么，晚上我回家在自己老硬盘里翻到以前的项目，才找到，这个东西叫 Configuration Wizard）
3.我忘了是MSP430还是CC2530里看到的一套，和上述两种同出一辙的底层映射方法。

接下来，我会以截图，或者上代码的形式，实际把这些东西，先展示出来，再写我自己的看法。

辛昕 · 发表于2017-11-18 01:30

首先是 MDK4的 Configuration Wizard
(MDK5以后我不知道还有没有，但反正我是没用过，也没见到一些厂商的例程有继续用这个东西。）

先上图，感受一下。

你最先看到的，是这么一个东西，是一个列表式的图表结构的勾选的东西，看起来很美好的。

然后，以最简单的GPIO和相对复杂但大家都熟悉的SPI为例，看看它设置的细节。
看起来真得挺美好的。

GPIO

SPI

辛昕 · 发表于2017-11-18 01:33

然而，它背后是个什么东西呢？
如果你注意到下方，它还有另一种格式，叫 Text Editor的话。

你大致上会看到这样的东西，我只截图一部分。
（随后，我会把上面对应的 GPIO IO1 和 SPI2 的代码，简单发上来，不用在意，你过一眼就好。）

辛昕 · 发表于2017-11-18 01:35

下面上这部分代码

其实这是一种配置文本，我能联想到的最接近的东西，要么是 JSON要么是XML。

GPIO：

// <e> IO 0
//==============================
// Enable or disable GPIO0
#define ENABLE_IO_0 1
//==============================
// <s.20>昵称
// Default: "IO"
#define IO_NAME0 "Relay1"
// Local GPIO define
// <o>Port <0=> GPIOA <1=> GPIOB <2=> GPIOC
// <3=> GPIOD <4=> GPIOE <5=> GPIOF <6=> GPIOG
// <7=> GPIOH <8=> GPIOI
// GPIO A,B,C,D...<->(0,1,2,3...)
// 0=GPIOA,1=GPIOB,...
// Default: GPIOA
#define PORT_GPIO0 5
// <o>Pin <0=> PIN0 <1=> PIN1 <2=> PIN2 <3=> PIN3 <4=> PIN4
// <5=> PIN5 <6=> PIN6 <7=> PIN7 <8=> PIN8 <9=> PIN9
// <10=> PIN10 <11=> PIN11 <12=> PIN12 <13=> PIN13
// <14=> PIN14 <15=> PIN15
// 0=PIN0,1=PIN1,...
// Default: PIN0
#define PIN_GPIO0 11
// <o>Mode <0x00=> GPIO_Mode_IN <0x01=> GPIO_Mode_Out
// <0x02=> GPIO_Mode_AF <0x03=> GPIO_Mode_AN
// (输入)GPIO_Mode_IN = 0x00
// (输出)GPIO_Mode_Out= 0x01
// (第二功能)GPIO_Mode_AF = 0x02
// (模拟)GPIO_Mode_AN = 0x03
// Default: (输入)GPIO_Mode_IN
#define MODE_GPIO0 0x01
// <o>Speed <0=> GPIO_Speed_2MHz
// <1=> GPIO_Speed_25MHz
// <2=> GPIO_Speed_50MHz
// <3=> GPIO_Speed_100MHz
// 0=GPIO_Speed_2MHz
// 1=GPIO_Speed_25MHz
// 2=GPIO_Speed_50MHz
// 3=GPIO_Speed_100MHz
// Default: GPIO_Speed_2MHz
#define SPEED_GPIO0 2
// <o>OUT TYPE <0=> GPIO_Output push-pull
// <1=> GPIO_Output open-drain
// 0=GPIO_Output push-pull
// 1=GPIO_Output open-drain
// Default: GPIO_Output push-pull
#define OTYPE_GPIO0 0
// <o>PU/PD <0=> GPIO_PuPd_NOPULL
// <1=> GPIO_PuPd_UP
// <2=> GPIO_PuPd_DOWN
// 0=GPIO_PuPd_NOPULL
// 1=GPIO_PuPd_UP
// 2=GPIO_PuPd_DOWN
// Default:GPIO_PuPd_NOPULL
#define PUPD_GPIO0 0
// <o>Init_state <0=> LOW <1=> HIGH
// 0=LOW
// 1=HIGH
// Default: LOW
#define STATE_GPIO0 0
// </e>

复制代码

SPI2

// <e> SPI2
//==============================
// Enable or disable SPI2
#define ENABLE_SPI2 1
//==============================
// <o>SPI prescaler <0x0000=> Div 2 <0x0008=> Div 4 <0x0010=> Div 8 <0x0018=> Div 16
// <0x0020=> Div 32 <0x0028=> Div 64 <0x0030=> Div 128 <0x0038=> Div 256
// 0x00000000 = Div 2, 0x00010000 = Div 4,...
// Default: Div 2
#define SPI2_PRESCALER 0x0038
// <o>Interrupt Priority <0=> High <1=> Middle <2=> Low
// Interrupt Priority
// Default: Low
#define SPI2_INT_PRIO 2
// <o>Clock Phase <0x0000=> 1Edge <0x0001=> 2Edge
// SPI Clock Phase 1=2Edge, 0=1Edge
// Default: 1Edge
#define SPI2_CPHA 0x0000
// <o>Clock Polarity <0x0002=> High <0x0000=> Low
// SPI Clock Phase 2=High, 0=Low
// Default: Low
#define SPI2_CPOL 0x0000
//<h> MOSI
// Local KEY define
// <o>Port <0=> GPIOA <1=> GPIOB <2=> GPIOC
// <3=> GPIOD <4=> GPIOE <5=> GPIOF <6=> GPIOG
// <7=> GPIOH <8=> GPIOI
// GPIO A,B,C,D...<->(0,1,2,3...)
// 0=GPIOA,1=GPIOB,...
// Default: GPIOA
#define PORT_SO_SPI2 2
// <o>Pin <0=> PIN0 <1=> PIN1 <2=> PIN2 <3=> PIN3 <4=> PIN4
// <5=> PIN5 <6=> PIN6 <7=> PIN7 <8=> PIN8 <9=> PIN9
// <10=> PIN10 <11=> PIN11 <12=> PIN12 <13=> PIN13
// <14=> PIN14 <15=> PIN15
// 0=PIN0,1=PIN1,...
// Default: PIN0
#define PIN_SO_SPI2 3
// <o>Mode <0x00=> GPIO_Mode_IN <0x01=> GPIO_Mode_Out
// <0x02=> GPIO_Mode_AF <0x03=> GPIO_Mode_AN
// (输入)GPIO_Mode_IN = 0x00
// (输出)GPIO_Mode_Out= 0x01
// (第二功能)GPIO_Mode_AF = 0x02
// (模拟)GPIO_Mode_AN = 0x03
// Default: (输入)GPIO_Mode_IN
#define MODE_SO_SPI2 0x02
// <o>Speed <0=> GPIO_Speed_2MHz
// <1=> GPIO_Speed_25MHz
// <2=> GPIO_Speed_50MHz
// <3=> GPIO_Speed_100MHz
// 0=GPIO_Speed_2MHz
// 1=GPIO_Speed_25MHz
// 2=GPIO_Speed_50MHz
// 3=GPIO_Speed_100MHz
// Default: GPIO_Speed_2MHz
#define SPEED_SO_SPI2 2
// <o>OUT TYPE <0=> GPIO_Output push-pull
// <1=> GPIO_Output open-drain
// 0=GPIO_Output push-pull
// 1=GPIO_Output open-drain
// Default: GPIO_Output push-pull
#define OTYPE_SO_SPI2 0
// <o>PU/PD <0=> GPIO_PuPd_NOPULL
// <1=> GPIO_PuPd_UP
// <2=> GPIO_PuPd_DOWN
// 0=GPIO_PuPd_NOPULL
// 1=GPIO_PuPd_UP
// 2=GPIO_PuPd_DOWN
// Default:GPIO_PuPd_NOPULL
#define PUPD_SO_SPI2 0
// <o>Init_state <0=> LOW <1=> HIGH
// 0=LOW
// 1=HIGH
// Default: LOW
#define STATE_SO_SPI2 0
//</h>
//-----------------------------------------------
//<h> MISO
// Local KEY define
// <o>Port <0=> GPIOA <1=> GPIOB <2=> GPIOC
// <3=> GPIOD <4=> GPIOE <5=> GPIOF <6=> GPIOG
// <7=> GPIOH <8=> GPIOI
// GPIO A,B,C,D...<->(0,1,2,3...)
// 0=GPIOA,1=GPIOB,...
// Default: GPIOA
#define PORT_SI_SPI2 2
// <o>Pin <0=> PIN0 <1=> PIN1 <2=> PIN2 <3=> PIN3 <4=> PIN4
// <5=> PIN5 <6=> PIN6 <7=> PIN7 <8=> PIN8 <9=> PIN9
// <10=> PIN10 <11=> PIN11 <12=> PIN12 <13=> PIN13
// <14=> PIN14 <15=> PIN15
// 0=PIN0,1=PIN1,...
// Default: PIN0
#define PIN_SI_SPI2 2
// <o>Mode <0x00=> GPIO_Mode_IN <0x01=> GPIO_Mode_Out
// <0x02=> GPIO_Mode_AF <0x03=> GPIO_Mode_AN
// (输入)GPIO_Mode_IN = 0x00
// (输出)GPIO_Mode_Out= 0x01
// (第二功能)GPIO_Mode_AF = 0x02
// (模拟)GPIO_Mode_AN = 0x03
// Default: (输入)GPIO_Mode_IN
#define MODE_SI_SPI2 0x02
// <o>Speed <0=> GPIO_Speed_2MHz
// <1=> GPIO_Speed_25MHz
// <2=> GPIO_Speed_50MHz
// <3=> GPIO_Speed_100MHz
// 0=GPIO_Speed_2MHz
// 1=GPIO_Speed_25MHz
// 2=GPIO_Speed_50MHz
// 3=GPIO_Speed_100MHz
// Default: GPIO_Speed_2MHz
#define SPEED_SI_SPI2 2
// <o>OUT TYPE <0=> GPIO_Output push-pull
// <1=> GPIO_Output open-drain
// 0=GPIO_Output push-pull
// 1=GPIO_Output open-drain
// Default: GPIO_Output push-pull
#define OTYPE_SI_SPI2 0
// <o>PU/PD <0=> GPIO_PuPd_NOPULL
// <1=> GPIO_PuPd_UP
// <2=> GPIO_PuPd_DOWN
// 0=GPIO_PuPd_NOPULL
// 1=GPIO_PuPd_UP
// 2=GPIO_PuPd_DOWN
// Default:GPIO_PuPd_NOPULL
#define PUPD_SI_SPI2 0
// <o>Init_state <0=> LOW <1=> HIGH
// 0=LOW
// 1=HIGH
// Default: LOW
#define STATE_SI_SPI2 0
//</h>
//-----------------------------------------
//<h> SCK
// Local KEY define
// <o>Port <0=> GPIOA <1=> GPIOB <2=> GPIOC
// <3=> GPIOD <4=> GPIOE <5=> GPIOF <6=> GPIOG
// <7=> GPIOH <8=> GPIOI
// GPIO A,B,C,D...<->(0,1,2,3...)
// 0=GPIOA,1=GPIOB,...
// Default: GPIOA
#define PORT_SCK_SPI2 1
// <o>Pin <0=> PIN0 <1=> PIN1 <2=> PIN2 <3=> PIN3 <4=> PIN4
// <5=> PIN5 <6=> PIN6 <7=> PIN7 <8=> PIN8 <9=> PIN9
// <10=> PIN10 <11=> PIN11 <12=> PIN12 <13=> PIN13
// <14=> PIN14 <15=> PIN15
// 0=PIN0,1=PIN1,...
// Default: PIN0
#define PIN_SCK_SPI2 10
// <o>Mode <0x00=> GPIO_Mode_IN <0x01=> GPIO_Mode_Out
// <0x02=> GPIO_Mode_AF <0x03=> GPIO_Mode_AN
// (输入)GPIO_Mode_IN = 0x00
// (输出)GPIO_Mode_Out= 0x01
// (第二功能)GPIO_Mode_AF = 0x02
// (模拟)GPIO_Mode_AN = 0x03
// Default: (输入)GPIO_Mode_IN
#define MODE_SCK_SPI2 0x02
// <o>Speed <0=> GPIO_Speed_2MHz
// <1=> GPIO_Speed_25MHz
// <2=> GPIO_Speed_50MHz
// <3=> GPIO_Speed_100MHz
// 0=GPIO_Speed_2MHz
// 1=GPIO_Speed_25MHz
// 2=GPIO_Speed_50MHz
// 3=GPIO_Speed_100MHz
// Default: GPIO_Speed_2MHz
#define SPEED_SCK_SPI2 2
// <o>OUT TYPE <0=> GPIO_Output push-pull
// <1=> GPIO_Output open-drain
// 0=GPIO_Output push-pull
// 1=GPIO_Output open-drain
// Default: GPIO_Output push-pull
#define OTYPE_SCK_SPI2 0
// <o>PU/PD <0=> GPIO_PuPd_NOPULL
// <1=> GPIO_PuPd_UP
// <2=> GPIO_PuPd_DOWN
// 0=GPIO_PuPd_NOPULL
// 1=GPIO_PuPd_UP
// 2=GPIO_PuPd_DOWN
// Default:GPIO_PuPd_NOPULL
#define PUPD_SCK_SPI2 0
// <o>Init_state <0=> LOW <1=> HIGH
// 0=LOW
// 1=HIGH
// Default: LOW
#define STATE_SCK_SPI2 0
//</h>
//---------------------------------------
//<h> CS
// Local KEY define
// <o>Port <0=> GPIOA <1=> GPIOB <2=> GPIOC
// <3=> GPIOD <4=> GPIOE <5=> GPIOF <6=> GPIOG
// <7=> GPIOH <8=> GPIOI
// GPIO A,B,C,D...<->(0,1,2,3...)
// 0=GPIOA,1=GPIOB,...
// Default: GPIOA
#define PORT_CS_SPI2 1
// <o>Pin <0=> PIN0 <1=> PIN1 <2=> PIN2 <3=> PIN3 <4=> PIN4
// <5=> PIN5 <6=> PIN6 <7=> PIN7 <8=> PIN8 <9=> PIN9
// <10=> PIN10 <11=> PIN11 <12=> PIN12 <13=> PIN13
// <14=> PIN14 <15=> PIN15
// 0=PIN0,1=PIN1,...
// Default: PIN0
#define PIN_CS_SPI2 9
// <o>Mode <0x00=> GPIO_Mode_IN <0x01=> GPIO_Mode_Out
// <0x02=> GPIO_Mode_AF <0x03=> GPIO_Mode_AN
// (输入)GPIO_Mode_IN = 0x00
// (输出)GPIO_Mode_Out= 0x01
// (第二功能)GPIO_Mode_AF = 0x02
// (模拟)GPIO_Mode_AN = 0x03
// Default: (输入)GPIO_Mode_IN
#define MODE_CS_SPI2 0x01
// <o>Speed <0=> GPIO_Speed_2MHz
// <1=> GPIO_Speed_25MHz
// <2=> GPIO_Speed_50MHz
// <3=> GPIO_Speed_100MHz
// 0=GPIO_Speed_2MHz
// 1=GPIO_Speed_25MHz
// 2=GPIO_Speed_50MHz
// 3=GPIO_Speed_100MHz
// Default: GPIO_Speed_2MHz
#define SPEED_CS_SPI2 2
// <o>OUT TYPE <0=> GPIO_Output push-pull
// <1=> GPIO_Output open-drain
// 0=GPIO_Output push-pull
// 1=GPIO_Output open-drain
// Default: GPIO_Output push-pull
#define OTYPE_CS_SPI2 0
// <o>PU/PD <0=> GPIO_PuPd_NOPULL
// <1=> GPIO_PuPd_UP
// <2=> GPIO_PuPd_DOWN
// 0=GPIO_PuPd_NOPULL
// 1=GPIO_PuPd_UP
// 2=GPIO_PuPd_DOWN
// Default:GPIO_PuPd_NOPULL
#define PUPD_CS_SPI2 0
// <o>Init_state <0=> LOW <1=> HIGH
// 0=LOW
// 1=HIGH
// Default: LOW
#define STATE_CS_SPI2 0
//</h>
// </e>

复制代码

如果你已经看到吐了，不用太震惊，因为我很早以前就吐过了。

所有的努力，不过是为了“定位BUG更容易，构建编码更快速”？ [复制链接]

最新回复

荣誉会员勋章