如何设置AutoCAD的默认界面为CAD2008经典界面

-打开AutoCAD2018软件
-进入未设置AutoCAD2018经典界面的默认操作界面(一般默认界面为“草图与注释”)

-在操作界面左上角找到如下菜单并点击,再点击显示菜单栏菜单,保证设置完后状态为隐藏菜单栏

-点击打开工具菜单,依次点击选项板,然后点击功能区(B),将功能区关闭。

关闭后界面如下

—-点击打开工具菜单,移动鼠标光标依次放至工具栏菜单,AutoCAD菜单。然后把标准栏,样式栏,图层栏,特性栏,绘图栏,修改栏,绘图次序栏点击打勾选中(此打勾操作一次只能选中一个,重复即可)。设置完成后显示为未保存的AutoCAD2018经典界面

更改后界面如下,为经典CAD工作窗口

-设置好经典界面所需内容后,找到界面底部操作菜单栏进行切换工作空间。点击选中将当前工作空间另存为菜单栏。

-将当前工作空间保存为AutoCAD 经典,这里需手动输入你想叫的名字,笔者这里选择了 AutoCAD 2018 经典 ,并点击保存

设置完之后即可将AutoCAD 2018的工作空间改为默认CAD经典

之后也可以通过 右下角的齿轮选项夹进行选择

 

至此,已经完成将AutoCAD 2018的工作空间改为CAD经典的操作了!

如何简易安装AutoCAD 2018🍔🍔

首先从网上下载好AutoCAD的安装包   🐎🐎🐎点我

提取码:2k3q    解压密码:MDRFB

-将下载好的压缩包进行解压,然后进入AutoCAD2018 64bit文件夹

打开如图的文件

更改解压文件夹至你想解压的地方(选择的不是软件安装位置)

移动到你选择的解压位置,进行软件安装

-双击打开Setup.exe

在安装程序中点击安装

选择“我接受”许可及服务协议,点击下一步

修改你需要安装的软件目录,并点击安装按钮

点击完成


等待安装完之后,询问是否重启电脑,点

-点击桌面上的AutoCAD软件或从开始菜单运行AutoCAD软件

点击输入序列号

点击激活

序列号输入:666-69696969

产品密钥输入:001J1,点击下一步

 

之后选择  我具有Autodesk提供的激活码


以管理员运行注册机

复制申请号到注册机的 Request 

点 Patch 出现 successfully pached 提示,点确定

 


Generate生成激活码

复制生成的激活码到 “我具有autodesk提供的激活码” 中


回到激活界面,点击下一步

即可激活成功!

之后即可开始 AutoCAD 2018 的学习工作!

在安装完成后,请继续以下操作,方便与学校机房的CAD软件教学接轨

  1. 更改AutoCAD2018的默认保存选项为2013兼容版(方便学校机房打开)
  2. 设置AutoCAD的默认界面为CAD2008经典界面

西门子UG NX V10.0 安装教程

请先在网上下载好UG NX10的安装包           

提取码:okqr

本资源为网上搜集,私自使用导致的后果与本站无关

-第一步:安装JAVA

请解压下载的压缩包,再找到JAVA安装文件,并双击进行JAVA的安装

-第二步:准备UGNX的安装文件

 

 

右键使用记事本打开splm6.lic文件

打开许可文件后,将第一行部分内容修改为计算机名

如图所示修改

-第三步:UGNX的准备安装

在你需要安装UGNX的地方创建一个文件夹(比如UG10.0)作为安装UG10.0的路径。

将上步骤修改好的许可文件“splm6.lic”放到此创建的文件夹

-开始西门子许可证安装

回到压缩包解压后的目录

双击打开安装应用

选择 Install License Server

单击”Choose”,选择前面创建的文件夹(UG10.0)作为安装路径。

单击“Next”。


单击”Choose”,选择前面修改过的许可文件”splm6.lic”。

单击“Next”。


单击“Instsll”进行安装。

弹出提示,单击OK“。

之后。单击”Done”完成安装。


打开“任务管理器”,在“详细信息列”找到两个“lmgrd.exe”文件将其结束。然后关闭“任务管理器”。


在“pj文件”文件夹里,找到并打开“PLMLicenseServer”文件夹。在“PLMLicenseServer”文件夹里找到”ugslmd”文件将其复制到安装目录。

选择 替换目标中的文件


 在安装目录找到“lmtools”文件,以管理员身份运行打开它。

单击”Start/Stop/Reresd”项,单击“Stsrt Server”,在左下角提示启动成功。单击”关闭“按钮关闭。
-开始NX10.0 主程序安装

回到安装界面,选择单击第三项”Instsll NX“安装主程序。

提示安装语言为简体中文,单击”确定“


前面直接按下一步

单击”更改“把安装路径改为前面创建的路径(E盘\UG10.0)。

单击”下一步“


输入服务器名直接点下一步

在选择语言时,选择”简体中文“,单击”下一步“


单击 安装 (I)

安装完成后点击 完成


将安装包里的“pj文件”文件夹里”UG10.0“文件夹里的所有文件夹复制粘贴到安装目录文件夹(粘贴时选择替换)。

 

-安装完成 开始使用吧!

 

个人创建基于rt_thread的项目

在学习了中断函数后突发奇想想自己创建一个用中断函数来控制led灯的闪烁,说干就干,期望达到的效果如下:

按下key1后蜂鸣器发出声音同时led以绿,蓝,红的顺序进行闪烁;按下key2后蜂鸣器停止发出声音同时led灯熄灭。

在经过一番操作后代码如下:

#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#define KEY0_PIN_NUM 0
#define BEEP_PIN_NUM 8

int jb,junbian;
/*完成对led的初始化*/
void led_start(){
  rt_pin_mode(16,PIN_MODE_OUTPUT);
  rt_pin_write(16,PIN_HIGH);
  rt_pin_mode(17,PIN_MODE_OUTPUT);
  rt_pin_write(17,PIN_HIGH);
  rt_pin_mode(21,PIN_MODE_OUTPUT);
  rt_pin_write(21,PIN_HIGH);	
}
/*完成对蜂鸣器的初始化*/
void jun_ready(){

  rt_pin_mode(8,PIN_MODE_OUTPUT);
  rt_pin_write(8,PIN_HIGH); 

}
/*完成led的闪烁控制*/
void jun_on(){
  
  rt_pin_write(16,PIN_LOW);
  rt_thread_delay(50);
  rt_pin_write(16,PIN_HIGH); 
  
  rt_pin_write(17,PIN_LOW);
  rt_thread_delay(50);
  rt_pin_write(17,PIN_HIGH);
  
  rt_pin_write(21,PIN_LOW);
  rt_thread_delay(50);
  rt_pin_write(21,PIN_HIGH);	
  
}
/*完成关闭led的控制*/
void jun_off(){
  rt_pin_write(8,PIN_LOW);
  rt_pin_write(16,PIN_HIGH);
  rt_pin_write(17,PIN_HIGH);
  rt_pin_write(21,PIN_HIGH);
}

void jun_start(){
  led_start();//调用led初始化函数
/*将key1和key2设置成上拉输入*/
  rt_pin_mode(0,PIN_MODE_INPUT_PULLUP );
  rt_pin_mode(45,PIN_MODE_INPUT_PULLUP );
  while(1){
  rt_pin_attach_irq(0,PIN_IRQ_MODE_FALLING,jun_ready,RT_NULL);//绑定引脚中断回调函数
  rt_pin_irq_enable(0,PIN_IRQ_ENABLE);//使能引脚中断
  
  jb=rt_pin_read(8);//读取蜂鸣器的电平
  
  if(jb==PIN_HIGH){
    while(jb==PIN_HIGH){
    jun_on();
  rt_pin_attach_irq(45,PIN_IRQ_MODE_FALLING,jun_off,RT_NULL);
  rt_pin_irq_enable(45,PIN_IRQ_ENABLE);
      junbian=rt_pin_read(8);
      if(junbian==PIN_LOW){
        break;
      }
      
    }
  }
}
}

MSH_CMD_EXPORT(jun_start,sat8 is the best)

现在说一下项目设计的思路,首先在完成对于引脚的初始化后我们首先要做的事就是实现闪烁功能,通过延时函数rt_thread_delay()我们可以轻易做到闪烁的功能。有关本项目所使用到的函数在这里我都写了注释:https://www.mdrfb.com/2019/09/03/examples-of-functions-in-rt_thread/

接下来就要解决用按钮控制的问题了,根据中断回调函数我们可以让程序在读到这一行的时候执行中断并作出相应的操作,

rt_pin_attach_irq(0,PIN_IRQ_MODE_FALLING,jun_ready,RT_NULL);//绑定引脚中断回调函数 
rt_pin_irq_enable(0,PIN_IRQ_ENABLE);//使能引脚中断

这两行实现了使用key1按钮来让蜂鸣器器响起来的功能因为蜂鸣器要和led灯一起闪烁所以我们需要时刻对蜂鸣器进行电平检测,当电平被检测为高时就代表我们的led就要开始闪起来了,

jb=rt_pin_read(8);//读取蜂鸣器的电平

这一行代码完成了对于蜂鸣器电平的检测,再根据if函数来执行检测到蜂鸣器电平为high时led开始闪烁的功能。

因为我们还要通过key2按钮来关闭led和蜂鸣器所以我们还要再打一行中断回调函数和使能引脚中断, 

 rt_pin_attach_irq(45,PIN_IRQ_MODE_FALLING,jun_off,RT_NULL);
 rt_pin_irq_enable(45,PIN_IRQ_ENABLE);

根据上文的思路,当蜂鸣器电平变低时led就要熄灭所以我们又添加了一条检测函数,

junbian=rt_pin_read(8);

再根据if判断语句和c语言中break指令完成对闪烁的中断,也就是跳出while循环,至此我们的操作目标已经都达成了。

在编写此类程序的时候有一点需要注意,有些人在编程时会忽略编译器对于读取程序的顺序,程序在运行时速度非常快所以有时候会发生这种情况,我的程序明明符合逻辑天衣无缝为什么下载到开发板上后功能却不完全或根本没有功能,为了达到随按随停,随按随开的功能我们要在主体函数外边加一个while(1)循环,也就是无限循环,否则就会发生按了按钮灯死活不亮的反应,因为你的程序早就被执行完毕了!

在rt_thread中使用线程来控制跑马灯

线程是rt_thread中一个非常重要的东西,它就好比我们在完成一个任务时我们通常会把任务分成一个个小任务然后一步一步来完成这个大任务。线程就好比我们一步一步做的小任务,所以对线程的掌握在学习rt_thread中是很重要的。

首先先贴上代码:

#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

static void ledjun(void *param){
  rt_pin_mode(16,PIN_MODE_OUTPUT);//控制引脚输出模式
  
  while(1){
    rt_pin_write(16,PIN_LOW);//控制引脚输出低电平
    rt_thread_mdelay(500);//延时50ms
    rt_pin_write(16,PIN_HIGH);
    rt_thread_mdelay(500);
  }
}
static void sat8(void){
rt_thread_t tid=rt_thread_create(
 "led",     //给予线程名字
  ledjun,   //设置入口函数
  RT_NULL,  //函数输入参数为无
  512,      //分配线程栈的大小
  10,       //线程优先级
  10);      //配置时间片参数
  if(tid!=RT_NULL)
    rt_thread_startup(tid);
}                    
MSH_CMD_EXPORT(sat8, sat8 is the best)

如果对rt_thread中函数掌握的比较牢固的话应该理解起来不难,首先完成对跑马灯程序的编写然后开始创建线程。

如何完成跑马灯的编程就不在这儿详细讲了,毕竟就这么点东西注释已经在旁边写好了,如果想详细了解一下跑马灯编程的可以看我之前写的:

在rt_thread中用main函数来实现跑马灯的功能

现在让我们把重点放在线程的创建上:

首先让我们从第一行开始看,我们先是调用了创建线程的函数也就是rt_thread_create,这个函数是rt_thread为我们创建的让我们来看看它的格式:

rt_thread_t rt_thread_create(const char *name,
                             void (*entry)(void *parameter),
                             void       *parameter,
                             rt_uint32_t stack_size,
                             rt_uint8_t  priority,
                             rt_uint32_t tick)
{

首先我们要为线程取一个名字,在这里我们取的名字是led;然后设置线程入口函数,因为我们要完成的效果是跑马灯而跑马灯的函数在上方已给出所以我们只要把我们已创建好的跑马灯的函数名字粘贴进去就好;接着我们要设置函数的输入参数,因为在这里我们并没有使用输入参数所以写了RT_NULL,鉴于可能有人不知道输入参数是什么那我们在这里简单的说一下,输入参数就是在函数内部定义的局部变量,举个例子:

void jun(int bian){}

在这里bian就是输入参数;接下来分配线程栈的大小,在这里我们设置成立512k;

下一步就是设置线程的优先级,在rt_thread中数字越小优先级越高,0是最高优先级;最后就是配置时间片参数。

至此我们已经成功将线程初始化完毕了,那么接下来就是要启动这个线程,

if(tid!=RT_NULL) 
  rt_thread_startup(tid);

因为创立线程需要在内存中分配空间以运行这个线程所以在提交完建立线程的请求后会给我们返回一个值以此来告诉我们线程的创建是否成功,如果不成功就返回RT_NULL,所以只要返回的不是RT_NULL我们就启动这个线程,在使用rt_thread_starup这个函数时要注意括号里的参数应该是线程的句柄,什么是句柄?句柄顾名思义是一个柄,它可以拉起一大堆的东西,这个东西就是我们用户自己定义的函数或者其他的一些东西(在这里就是我们自己创建的线程),在某些方面句柄和指针差不多(注意,这里只是差不多,区别还是有的)。

到这里,我们就大功告成了!是不是很开心?让我们来看看我们的劳动成果,咦?为什么我们的开发板一点反应都没有?是不是哪编错了?我可以很负责任的告诉你刚才你做的都没有错,错就错在使用线程时我们要进行串口输出,通过将函数添加到msh命令列表来输出函数,大家可以去下载一个串口调试工具这样在调试时会方便一些。

MSH_CMD_EXPORT(sat8,sat8 is the best)

这段代码中的MSH_CMD_EXPORT就是msh提供的函数以此来将用户函数添加到msh命令列表中,sat8就是我们给跑马灯函数起的名字,sat8 is the best是用户自己定义的,多半情况下你可以把注释或标记写进去,在这里我们写的是sat8 is the best

到这步才算是真正的结束,现在我们把程序编译一下再下载进去led就能闪起来了。

 

 

小狮子,带侦探(联动篇),另外一个视角?

继小狮子,带侦探的第一季的完结,就让我给大家展现另外一个神秘人物的视角。

大家好,我叫C-MS,继指挥官不见以后,格里芬基地里面开始变得杂乱起来,很多人形开始了偷懒,许多岗位开始无人监管,小狮子(S.A.T.8)于是自发组织小队去寻找指挥官,就在前几天,基地接收到小狮子的消息,她们已经根据指挥官留下的线索前往了英国,具体进展并不清楚。

于是我打算也加入到寻找指挥官的队伍中,在指挥官的办公室里面,有明显翻过的痕迹,看来是小狮子她们翻的,有点杂乱,我还是收拾一下把。

1小时后,指挥官的办公室变得一尘不染,每个文件都回到了它们该去的地方。

但是在C-MS整理的途中,发现书架的一处不起眼的角落却没有任何翻动的痕迹,异常的整齐,其他物品因为指挥官的长时间不在,上面积满了灰尘,但是这个角落似乎不会受到灰尘的侵略。

在这个角落里面躺了一本书,是一本原子弹制造指南,C-MS满脸黑线,为什么指挥官有这个书,而且非常的干净,难道里面有什么特殊的东西吗,C-MS翻了几下:原子弹想要93.8%纯度的球形铀-235,密度为18.75g/立方米时候,临界质量大约为52kg。。。。。。。。。铀-238和铀-235有同样的质子数但多了3个中子属于同位素。。。。
。等等的C-MS看不懂的东西。但是当C-MS把书合上的时候,发现封面右下角有

#include <stdio.h>
int main()
{
int a ;(紫色笔写的)
Cin>>a;
                                                                                   int b ;(黑色笔写的)
Cin>>b;

int c ;
  c = a + b;
printf("文件编号是 %d\n", c );

 

 

 

C-MS陷入了沉思,看着这2个颜色的痕迹,突然抬起来头,眼睛在书架的其他地方开始寻找,突然发现平常非常习以为常,但是现在感觉非常其他的2个文件夹,书架上面的标签分别用黑色和紫色的标签。C-MS拿下了这2个文件,一份是如何设计一个逼真的三维模型,另外一份是格里芬作战记录。C-MS特别仔细的阅读了这2个文件,并没有发现上面。C-MS觉得自己因为思考过度,脑子发热严重。C-MS拉过指挥官的椅子一把坐了下去。就在C-MS昏昏欲睡的时候,眼睛扫过标签,发现紫色标签上有除了标记的字体,还有什么东西让紫色的边缘不是那么干净。

C-MS立马一个激灵从椅子上爬了起来,发现紫色标签上面是一个数值,C-MS突然灵光一闪,发现黑色的标签上面也有,于是C-MS用一开始的C语音的算术运算,得到了一串数值。C-MS马上联系了格琳娜。格琳娜在格里芬的资料库里面找到了文件叫一份关于一个度假胜地的介绍文件,难道指挥官在那里?

预知后事如何,请看 小狮子,带侦探(联动篇)  前往度假胜地

带结局?

欢迎来到今天的“小狮子 带侦探”!上回我们讲到我们去了英国的赫里福基地去寻找指挥官的下落,但是在准备去时候我们全体接到了命令,没错!是指挥官发来的!指挥官说他这几天出去修假(跑路)了叫我们平时听格林娜的话。

至此,我们查出了指挥官失踪的原因和下落(?)我宣布“小狮子 带侦探”第一季圆满结束!我是最可爱的人形sat8,我们有缘再见!

个人对于rt_thread中函数的理解和例子

//此文章会不间断进行更新,速度为作者学习的速度(捂脸)

1,rt_pin_mode()

此函数是用来完成对引脚的选择和控制输入还是输出模式。

示例:rt_pin_mode(16,PIN_MODE_OUTPUT)

2,rt_pin_write()

此函数是用来完成对引脚的输出高低电平的控制。

示例:rt_pin_write(16,PIN_LOW)

3,rt_mdelay()

此函数是用来将线程挂起来完成延时操作,延时单位为毫秒(ms)。

示例:rt_mdelay(500)

4,rt_delay()

此函数是用来线程挂起来完成延时操作,延时单位为系统滴答,一般我们设置系统时钟滴答的频率为100hz,也就是一个滴答为10ms。

示例:rt_delay(50)

5,rt_thread_create()

此函数是用来创建动态线程用的,具体方式如下:

rt_thread_t rt_thread_create(const char *name,
                             void (*entry)(void *parameter),
                             void       *parameter,
                             rt_uint32_t stack_size,
                             rt_uint8_t  priority,
                             rt_uint32_t tick)

创建一个动态线程分为这么几步:1,给出线程名字。2,设置入口函数。3,设置函数输入参数。4,定义线程栈的大小。5,设置线程优先级,数字越小优先级越高,0为最高优先级。6,配置线程时间片。

示例:

rt_threat jun=rt_thread_create("junbian",junbian,RT_NULL,512k,5,10)

在示例中假定我们创建的入口函数名称为junbian,RT_NULL所表示的意思为无输入参数。

6,rt_thread_starup()

此函数是用来启动线程的。

示例:rt_thread_starup(jun)

在这里jun假定为线程的句柄。

7,MSH_CMD_EXPORT()

这个严格意义上来说并不是函数而是命令,但是在编程时运用广泛所以也就把它和函数写一块了。可以通过这条命令来来将你所需要执行的线程或函数发送到MSH命令行,然后msh命令列表会通过串口进行输出。

示例:MSH_CMD_EXPORT(sat8,sat8 is the best)

在这里假定sat8为线程名字,逗号后面为用户自己定义的,你可以把注释或者标签写进去,在这里我们写的是sat8 is the best。

8,rt_pin_attach_irq()

此函数是用来绑定引脚中断的回调函数。什么是引脚中断回调函数?当一个引脚猝发某种情况时会将当前任务中断并完成用户指定的另一个任务。

rt_pin_attach_irq(rt_int32_t pin, rt_uint32_t mode,
                             void (*hdr)(void *args), void  *args)

这是官方给出的格式,首先确定需要绑定的引脚,再选择触发中断的条件,接着选择触发条件时需要执行的函数,最后设置中断回调函数的参数(不需要时设置为RT_NULL)。

示例:rt_pin_attach_enable(0,PIN_IRQ_MODE_FALLING,jun_ready,RT_NULL)

9,rt_pin_irq_enable()

此函数是用来使能引脚中断的,当我们绑定完引脚中断的回调函数后需要使能引脚中断,也就是给出信号让引脚开始执行中断并执行中断函数。

rt_pin_irq_enable(rt_base_t pin, rt_uint32_t enabled)

这是官方给出的格式,首先设置引脚,再设置状态,状态有两种enable和disable。

示例: rt_pin_irq_enable(0,PIN_IRQ_ENABLE);

在rt_thread中用main函数来实现跑马灯的功能

跑马灯是大部分学习单片机的初学者编的第一个程序,在使用rt_thread嵌入式系统编程时完成对跑马灯的编程可谓是学习rt_thread的第一课,话不多说直接上代码:

#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

int main(){
rt_pin_mode(16,PIN_MODE_OUTPUT);
  
  while(1){
    rt_pin_write(16,PIN_LOW);
    rt_thread_mdelay(500);
    rt_pin_write(16,PIN_HIGH);
    rt_thread_mdelay(500);
  }
return RT_EOK;
}

这里使用的开发板是野火f103,正常来讲使用rt_thread编程时要先创立线程但是今天我们先不创建,试试看直接用main函数能不能让跑马灯亮起来。

我们先从main函数的第一行看起:

rt_pin_mode(16,PIN_MODE_OUTPUT)这行的意思就是先确定我们要对哪个引脚进行操作然后确定它的输入输出模式,这里要解释一下括号中16是什么意思,首先让我们打开内核文件drv_gpio.c

static const struct pin_index pins[] = 
{
#if defined(GPIOA)
    __STM32_PIN(0 ,  A, 0 ),
    __STM32_PIN(1 ,  A, 1 ),
    __STM32_PIN(2 ,  A, 2 ),
    __STM32_PIN(3 ,  A, 3 ),
    __STM32_PIN(4 ,  A, 4 ),
    __STM32_PIN(5 ,  A, 5 ),
    __STM32_PIN(6 ,  A, 6 ),
    __STM32_PIN(7 ,  A, 7 ),
    __STM32_PIN(8 ,  A, 8 ),
    __STM32_PIN(9 ,  A, 9 ),
    __STM32_PIN(10,  A, 10),
    __STM32_PIN(11,  A, 11),
    __STM32_PIN(12,  A, 12),
    __STM32_PIN(13,  A, 13),
    __STM32_PIN(14,  A, 14),
    __STM32_PIN(15,  A, 15),
#if defined(GPIOB)
    __STM32_PIN(16,  B, 0),
    __STM32_PIN(17,  B, 1),
    __STM32_PIN(18,  B, 2),
    __STM32_PIN(19,  B, 3),
    __STM32_PIN(20,  B, 4),
    __STM32_PIN(21,  B, 5),
    __STM32_PIN(22,  B, 6),
    __STM32_PIN(23,  B, 7),
    __STM32_PIN(24,  B, 8),
    __STM32_PIN(25,  B, 9),
    __STM32_PIN(26,  B, 10),
    __STM32_PIN(27,  B, 11),
    __STM32_PIN(28,  B, 12),
    __STM32_PIN(29,  B, 13),
    __STM32_PIN(30,  B, 14),
    __STM32_PIN(31,  B, 15),
#if defined(GPIOC)
    __STM32_PIN(32,  C, 0),
    __STM32_PIN(33,  C, 1),
    __STM32_PIN(34,  C, 2),
    __STM32_PIN(35,  C, 3),
    __STM32_PIN(36,  C, 4),
    __STM32_PIN(37,  C, 5),
    __STM32_PIN(38,  C, 6),
    __STM32_PIN(39,  C, 7),
    __STM32_PIN(40,  C, 8),
    __STM32_PIN(41,  C, 9),
    __STM32_PIN(42,  C, 10),
    __STM32_PIN(43,  C, 11),
    __STM32_PIN(44,  C, 12),
    __STM32_PIN(45,  C, 13),
    __STM32_PIN(46,  C, 14),
    __STM32_PIN(47,  C, 15),
#if defined(GPIOD)
    __STM32_PIN(48,  D, 0),
    __STM32_PIN(49,  D, 1),
    __STM32_PIN(50,  D, 2),
    __STM32_PIN(51,  D, 3),
    __STM32_PIN(52,  D, 4),
    __STM32_PIN(53,  D, 5),
    __STM32_PIN(54,  D, 6),
    __STM32_PIN(55,  D, 7),
    __STM32_PIN(56,  D, 8),
    __STM32_PIN(57,  D, 9),
    __STM32_PIN(58,  D, 10),
    __STM32_PIN(59,  D, 11),
    __STM32_PIN(60,  D, 12),
    __STM32_PIN(61,  D, 13),
    __STM32_PIN(62,  D, 14),
    __STM32_PIN(63,  D, 15),
#if defined(GPIOE)
    __STM32_PIN(64,  E, 0),
    __STM32_PIN(65,  E, 1),
    __STM32_PIN(66,  E, 2),
    __STM32_PIN(67,  E, 3),
    __STM32_PIN(68,  E, 4),
    __STM32_PIN(69,  E, 5),
    __STM32_PIN(70,  E, 6),
    __STM32_PIN(71,  E, 7),
    __STM32_PIN(72,  E, 8),
    __STM32_PIN(73,  E, 9),
    __STM32_PIN(74,  E, 10),
    __STM32_PIN(75,  E, 11),
    __STM32_PIN(76,  E, 12),
    __STM32_PIN(77,  E, 13),
    __STM32_PIN(78,  E, 14),
    __STM32_PIN(79,  E, 15),
#if defined(GPIOF)
    __STM32_PIN(80,  F, 0),
    __STM32_PIN(81,  F, 1),
    __STM32_PIN(82,  F, 2),
    __STM32_PIN(83,  F, 3),
    __STM32_PIN(84,  F, 4),
    __STM32_PIN(85,  F, 5),
    __STM32_PIN(86,  F, 6),
    __STM32_PIN(87,  F, 7),
    __STM32_PIN(88,  F, 8),
    __STM32_PIN(89,  F, 9),
    __STM32_PIN(90,  F, 10),
    __STM32_PIN(91,  F, 11),
    __STM32_PIN(92,  F, 12),
    __STM32_PIN(93,  F, 13),
    __STM32_PIN(94,  F, 14),
    __STM32_PIN(95,  F, 15),
#if defined(GPIOG)
    __STM32_PIN(96,  G, 0),
    __STM32_PIN(97,  G, 1),
    __STM32_PIN(98,  G, 2),
    __STM32_PIN(99,  G, 3),
    __STM32_PIN(100, G, 4),
    __STM32_PIN(101, G, 5),
    __STM32_PIN(102, G, 6),
    __STM32_PIN(103, G, 7),
    __STM32_PIN(104, G, 8),
    __STM32_PIN(105, G, 9),
    __STM32_PIN(106, G, 10),
    __STM32_PIN(107, G, 11),
    __STM32_PIN(108, G, 12),
    __STM32_PIN(109, G, 13),
    __STM32_PIN(110, G, 14),
    __STM32_PIN(111, G, 15),
#if defined(GPIOH)
    __STM32_PIN(112, H, 0),
    __STM32_PIN(113, H, 1),
    __STM32_PIN(114, H, 2),
    __STM32_PIN(115, H, 3),
    __STM32_PIN(116, H, 4),
    __STM32_PIN(117, H, 5),
    __STM32_PIN(118, H, 6),
    __STM32_PIN(119, H, 7),
    __STM32_PIN(120, H, 8),
    __STM32_PIN(121, H, 9),
    __STM32_PIN(122, H, 10),
    __STM32_PIN(123, H, 11),
    __STM32_PIN(124, H, 12),
    __STM32_PIN(125, H, 13),
    __STM32_PIN(126, H, 14),
    __STM32_PIN(127, H, 15),
#if defined(GPIOI)
    __STM32_PIN(128, I, 0),
    __STM32_PIN(129, I, 1),
    __STM32_PIN(130, I, 2),
    __STM32_PIN(131, I, 3),
    __STM32_PIN(132, I, 4),
    __STM32_PIN(133, I, 5),
    __STM32_PIN(134, I, 6),
    __STM32_PIN(135, I, 7),
    __STM32_PIN(136, I, 8),
    __STM32_PIN(137, I, 9),
    __STM32_PIN(138, I, 10),
    __STM32_PIN(139, I, 11),
    __STM32_PIN(140, I, 12),
    __STM32_PIN(141, I, 13),
    __STM32_PIN(142, I, 14),
    __STM32_PIN(143, I, 15),
#if defined(GPIOJ)
    __STM32_PIN(144, J, 0),
    __STM32_PIN(145, J, 1),
    __STM32_PIN(146, J, 2),
    __STM32_PIN(147, J, 3),
    __STM32_PIN(148, J, 4),
    __STM32_PIN(149, J, 5),
    __STM32_PIN(150, J, 6),
    __STM32_PIN(151, J, 7),
    __STM32_PIN(152, J, 8),
    __STM32_PIN(153, J, 9),
    __STM32_PIN(154, J, 10),
    __STM32_PIN(155, J, 11),
    __STM32_PIN(156, J, 12),
    __STM32_PIN(157, J, 13),
    __STM32_PIN(158, J, 14),
    __STM32_PIN(159, J, 15),
#if defined(GPIOK)
    __STM32_PIN(160, K, 0),
    __STM32_PIN(161, K, 1),
    __STM32_PIN(162, K, 2),
    __STM32_PIN(163, K, 3),
    __STM32_PIN(164, K, 4),
    __STM32_PIN(165, K, 5),
    __STM32_PIN(166, K, 6),
    __STM32_PIN(167, K, 7),
    __STM32_PIN(168, K, 8),
    __STM32_PIN(169, K, 9),
    __STM32_PIN(170, K, 10),
    __STM32_PIN(171, K, 11),
    __STM32_PIN(172, K, 12),
    __STM32_PIN(173, K, 13),
    __STM32_PIN(174, K, 14),
    __STM32_PIN(175, K, 15),

在这里我们为每一个引脚都定义了一个宏,在开发板里led的绿灯所对应的引脚是PB0也就是gpioB第0号引脚(具体可以看开发板的原理图)

__STM32_PIN(16, B, 0),

这一行就是为PB0定义的宏,可以看到在括号内有3个数字,第一个数字就是这个引脚所对应的编号也就是16。

#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

int main(){
rt_pin_mode(16,PIN_MODE_OUTPUT);
  
  while(1){
    rt_pin_write(16,PIN_LOW);
    rt_thread_mdelay(500);
    rt_pin_write(16,PIN_HIGH);
    rt_thread_mdelay(500);
  }
}

再让我们回到main函数中,括号里第二个参数应该很好理解,就是选择推挽输出模式同样再内核文件中也能看到关于输入输出的宏。

#define PIN_MODE_OUTPUT         0x00
#define PIN_MODE_INPUT          0x01
#define PIN_MODE_INPUT_PULLUP   0x02
#define PIN_MODE_INPUT_PULLDOWN 0x03
#define PIN_MODE_OUTPUT_OD      0x04

那么这一行是什么意思就一目了然了,选择PB0这个引脚并使用推挽输出模式。接下来让我们看while循环,(1)表示此循环无限运作下去(但通过对线程的操控可以让它关闭,具体的以后会讲)

rt_pin_write(16,PIN_LOW); 
rt_thread_mdelay(500); 
rt_pin_write(16,PIN_HIGH);
rt_thread_mdelay(500);

while循环中是我们用来点亮跑马灯并且让他闪烁的,第一句就是让PB0输出低电平,在rt_thread中所有引用的参数都是事先定义好的宏所以可以参照上文来找到它的原型,第二句是时钟函数就是延时50ms后读取下一行代码,rt_thread中时钟函数有很多种,如rt_thread_delay(使用系统滴答来完成延时操作,括号内参数应改成50,也就是50个系统滴答)。在搞清楚前两行代码是什么意思后整个while循环的意思就应该很清晰了,通过对引脚输出高低电平并适当的延时就能完成闪烁这个操作。

在rt_thread中用main函数来实现跑马灯的功能还是算蛮简单的,如果有学习过库函数编程应该会一看就懂,但是这种做法在现实中是几乎不会使用的,因为这样子编程和使用库函数编程没什么区别,也就是无法体现出tr_thread的特点。正常情况下是要创建线程后再进行用户函数的编写。