发布于

个人对于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的特点。正常情况下是要创建线程后再进行用户函数的编写。

 

发布于

重大线索发现！

欢迎收看今天的“小狮子 带侦探”！我是最可爱的人形s.a.t.8。在后勤官格林娜小姐的指挥下指挥部所有的人形对整个指挥部区域进行了地毯式搜索，在指挥室中的电脑里我们又发现了一串可疑的代码：

;******************** (C) COPYRIGHT 2011 STMicroelectronics ********************
;* File Name          : startup_stm32f10x_hd.s
;* Author             : MCD Application Team
;* Version            : V3.5.0
;* Date               : 11-March-2011
;* Description        : STM32F10x High Density Devices vector table for MDK-ARM 
;*                      toolchain. 
;*                      This module performs:
;*                      - Set the initial SP
;*                      - Set the initial PC == Reset_Handler
;*                      - Set the vector table entries with the exceptions ISR address
;*                      - Configure the clock system and also configure the external 
;*                        SRAM mounted on STM3210E-EVAL board to be used as data 
;*                        memory (optional, to be enabled by user)
;*                      - Branches to __main in the C library (which eventually
;*                        calls main()).
;*                      After Reset the CortexM3 processor is in Thread mode,
;*                      priority is Privileged, and the Stack is set to Main.
;* <<< Use Configuration Wizard in Context Menu >>>   
;*******************************************************************************
; THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
; WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
; AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
; INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
; CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
; INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
;*******************************************************************************

; Amount of memory (in bytes) allocated for Stack
; Tailor this value to your application needs
; <h> Stack Configuration
;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Stack_Size      EQU     0x00000400

                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size
__initial_sp
                                                  
; <h> Heap Configuration
;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Heap_Size       EQU     0x00000200

                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit

                PRESERVE8
                THUMB


; Vector Table Mapped to Address 0 at Reset
                AREA    RESET, DATA, READONLY
                EXPORT  __Vectors
                EXPORT  __Vectors_End
                EXPORT  __Vectors_Size

__Vectors       DCD     __initial_sp               ; Top of Stack
                DCD     Reset_Handler              ; Reset Handler
                DCD     NMI_Handler                ; NMI Handler
                DCD     HardFault_Handler          ; Hard Fault Handler
                DCD     MemManage_Handler          ; MPU Fault Handler
                DCD     BusFault_Handler           ; Bus Fault Handler
                DCD     UsageFault_Handler         ; Usage Fault Handler
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     SVC_Handler                ; SVCall Handler
                DCD     DebugMon_Handler           ; Debug Monitor Handler
                DCD     0                          ; Reserved
                DCD     PendSV_Handler             ; PendSV Handler
                DCD     SysTick_Handler            ; SysTick Handler

                ; External Interrupts
                DCD     WWDG_IRQHandler            ; Window Watchdog
                DCD     PVD_IRQHandler             ; PVD through EXTI Line detect
                DCD     TAMPER_IRQHandler          ; Tamper
                DCD     RTC_IRQHandler             ; RTC
                DCD     FLASH_IRQHandler           ; Flash
                DCD     RCC_IRQHandler             ; RCC
                DCD     EXTI0_IRQHandler           ; EXTI Line 0
                DCD     EXTI1_IRQHandler           ; EXTI Line 1
                DCD     EXTI2_IRQHandler           ; EXTI Line 2
                DCD     EXTI3_IRQHandler           ; EXTI Line 3
                DCD     EXTI4_IRQHandler           ; EXTI Line 4
                DCD     DMA1_Channel1_IRQHandler   ; DMA1 Channel 1
                DCD     DMA1_Channel2_IRQHandler   ; DMA1 Channel 2
                DCD     DMA1_Channel3_IRQHandler   ; DMA1 Channel 3
                DCD     DMA1_Channel4_IRQHandler   ; DMA1 Channel 4
                DCD     DMA1_Channel5_IRQHandler   ; DMA1 Channel 5
                DCD     DMA1_Channel6_IRQHandler   ; DMA1 Channel 6
                DCD     DMA1_Channel7_IRQHandler   ; DMA1 Channel 7
                DCD     ADC1_2_IRQHandler          ; ADC1 & ADC2
                DCD     USB_HP_CAN1_TX_IRQHandler  ; USB High Priority or CAN1 TX
                DCD     USB_LP_CAN1_RX0_IRQHandler ; USB Low  Priority or CAN1 RX0
                DCD     CAN1_RX1_IRQHandler        ; CAN1 RX1
                DCD     CAN1_SCE_IRQHandler        ; CAN1 SCE
                DCD     EXTI9_5_IRQHandler         ; EXTI Line 9..5
                DCD     TIM1_BRK_IRQHandler        ; TIM1 Break
                DCD     TIM1_UP_IRQHandler         ; TIM1 Update
                DCD     TIM1_TRG_COM_IRQHandler    ; TIM1 Trigger and Commutation
                DCD     TIM1_CC_IRQHandler         ; TIM1 Capture Compare
                DCD     TIM2_IRQHandler            ; TIM2
                DCD     TIM3_IRQHandler            ; TIM3
                DCD     TIM4_IRQHandler            ; TIM4
                DCD     I2C1_EV_IRQHandler         ; I2C1 Event
                DCD     I2C1_ER_IRQHandler         ; I2C1 Error
                DCD     I2C2_EV_IRQHandler         ; I2C2 Event
                DCD     I2C2_ER_IRQHandler         ; I2C2 Error
                DCD     SPI1_IRQHandler            ; SPI1
                DCD     SPI2_IRQHandler            ; SPI2
                DCD     USART1_IRQHandler          ; USART1
                DCD     USART2_IRQHandler          ; USART2
                DCD     USART3_IRQHandler          ; USART3
                DCD     EXTI15_10_IRQHandler       ; EXTI Line 15..10
                DCD     RTCAlarm_IRQHandler        ; RTC Alarm through EXTI Line
                DCD     USBWakeUp_IRQHandler       ; USB Wakeup from suspend
                DCD     TIM8_BRK_IRQHandler        ; TIM8 Break
                DCD     TIM8_UP_IRQHandler         ; TIM8 Update
                DCD     TIM8_TRG_COM_IRQHandler    ; TIM8 Trigger and Commutation
                DCD     TIM8_CC_IRQHandler         ; TIM8 Capture Compare
                DCD     ADC3_IRQHandler            ; ADC3
                DCD     FSMC_IRQHandler            ; FSMC
                DCD     SDIO_IRQHandler            ; SDIO
                DCD     TIM5_IRQHandler            ; TIM5
                DCD     SPI3_IRQHandler            ; SPI3
                DCD     UART4_IRQHandler           ; UART4
                DCD     UART5_IRQHandler           ; UART5
                DCD     TIM6_IRQHandler            ; TIM6
                DCD     TIM7_IRQHandler            ; TIM7
                DCD     DMA2_Channel1_IRQHandler   ; DMA2 Channel1
                DCD     DMA2_Channel2_IRQHandler   ; DMA2 Channel2
                DCD     DMA2_Channel3_IRQHandler   ; DMA2 Channel3
                DCD     DMA2_Channel4_5_IRQHandler ; DMA2 Channel4 & Channel5
__Vectors_End

__Vectors_Size  EQU  __Vectors_End - __Vectors

                AREA    |.text|, CODE, READONLY
              
; Reset handler
Reset_Handler   PROC
                EXPORT  Reset_Handler             [WEAK]
                IMPORT  __main
                IMPORT  SystemInit
                LDR     R0, =SystemInit
                BLX     R0               
                LDR     R0, =__main
                BX      R0
                ENDP
               
; Dummy Exception Handlers (infinite loops which can be modified)

NMI_Handler     PROC
                EXPORT  NMI_Handler                [WEAK]
                B       .
                ENDP
HardFault_Handler\
                PROC
                EXPORT  HardFault_Handler          [WEAK]
                B       .
                ENDP
MemManage_Handler\
                PROC
                EXPORT  MemManage_Handler          [WEAK]
                B       .
                ENDP
BusFault_Handler\
                PROC
                EXPORT  BusFault_Handler           [WEAK]
                B       .
                ENDP
UsageFault_Handler\
                PROC
                EXPORT  UsageFault_Handler         [WEAK]
                B       .
                ENDP
SVC_Handler     PROC
                EXPORT  SVC_Handler                [WEAK]
                B       .
                ENDP
DebugMon_Handler\
                PROC
                EXPORT  DebugMon_Handler           [WEAK]
                B       .
                ENDP
PendSV_Handler  PROC
                EXPORT  PendSV_Handler             [WEAK]
                B       .
                ENDP
SysTick_Handler PROC
                EXPORT  SysTick_Handler            [WEAK]
                B       .
                ENDP

Default_Handler PROC

                EXPORT  WWDG_IRQHandler            [WEAK]
                EXPORT  PVD_IRQHandler             [WEAK]
                EXPORT  TAMPER_IRQHandler          [WEAK]
                EXPORT  RTC_IRQHandler             [WEAK]
                EXPORT  FLASH_IRQHandler           [WEAK]
                EXPORT  RCC_IRQHandler             [WEAK]
                EXPORT  EXTI0_IRQHandler           [WEAK]
                EXPORT  EXTI1_IRQHandler           [WEAK]
                EXPORT  EXTI2_IRQHandler           [WEAK]
                EXPORT  EXTI3_IRQHandler           [WEAK]
                EXPORT  EXTI4_IRQHandler           [WEAK]
                EXPORT  DMA1_Channel1_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel2_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel3_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel4_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel5_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel6_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel7_IRQHandler   [WEAK]
                EXPORT  ADC1_2_IRQHandler          [WEAK]
                EXPORT  USB_HP_CAN1_TX_IRQHandler  [WEAK]
                EXPORT  USB_LP_CAN1_RX0_IRQHandler [WEAK]
                EXPORT  CAN1_RX1_IRQHandler        [WEAK]
                EXPORT  CAN1_SCE_IRQHandler        [WEAK]
                EXPORT  EXTI9_5_IRQHandler         [WEAK]
                EXPORT  TIM1_BRK_IRQHandler        [WEAK]
                EXPORT  TIM1_UP_IRQHandler         [WEAK]
                EXPORT  TIM1_TRG_COM_IRQHandler    [WEAK]
                EXPORT  TIM1_CC_IRQHandler         [WEAK]
                EXPORT  TIM2_IRQHandler            [WEAK]
                EXPORT  TIM3_IRQHandler            [WEAK]
                EXPORT  TIM4_IRQHandler            [WEAK]
                EXPORT  I2C1_EV_IRQHandler         [WEAK]
                EXPORT  I2C1_ER_IRQHandler         [WEAK]
                EXPORT  I2C2_EV_IRQHandler         [WEAK]
                EXPORT  I2C2_ER_IRQHandler         [WEAK]
                EXPORT  SPI1_IRQHandler            [WEAK]
                EXPORT  SPI2_IRQHandler            [WEAK]
                EXPORT  USART1_IRQHandler          [WEAK]
                EXPORT  USART2_IRQHandler          [WEAK]
                EXPORT  USART3_IRQHandler          [WEAK]
                EXPORT  EXTI15_10_IRQHandler       [WEAK]
                EXPORT  RTCAlarm_IRQHandler        [WEAK]
                EXPORT  USBWakeUp_IRQHandler       [WEAK]
                EXPORT  TIM8_BRK_IRQHandler        [WEAK]
                EXPORT  TIM8_UP_IRQHandler         [WEAK]
                EXPORT  TIM8_TRG_COM_IRQHandler    [WEAK]
                EXPORT  TIM8_CC_IRQHandler         [WEAK]
                EXPORT  ADC3_IRQHandler            [WEAK]
                EXPORT  FSMC_IRQHandler            [WEAK]
                EXPORT  SDIO_IRQHandler            [WEAK]
                EXPORT  TIM5_IRQHandler            [WEAK]
                EXPORT  SPI3_IRQHandler            [WEAK]
                EXPORT  UART4_IRQHandler           [WEAK]
                EXPORT  UART5_IRQHandler           [WEAK]
                EXPORT  TIM6_IRQHandler            [WEAK]
                EXPORT  TIM7_IRQHandler            [WEAK]
                EXPORT  DMA2_Channel1_IRQHandler   [WEAK]
                EXPORT  DMA2_Channel2_IRQHandler   [WEAK]
                EXPORT  DMA2_Channel3_IRQHandler   [WEAK]
                EXPORT  DMA2_Channel4_5_IRQHandler [WEAK]

WWDG_IRQHandler
PVD_IRQHandler
TAMPER_IRQHandler
RTC_IRQHandler
FLASH_IRQHandler
RCC_IRQHandler
EXTI0_IRQHandler
EXTI1_IRQHandler
EXTI2_IRQHandler
EXTI3_IRQHandler
EXTI4_IRQHandler
DMA1_Channel1_IRQHandler
DMA1_Channel2_IRQHandler
DMA1_Channel3_IRQHandler
DMA1_Channel4_IRQHandler
DMA1_Channel5_IRQHandler
DMA1_Channel6_IRQHandler
DMA1_Channel7_IRQHandler
ADC1_2_IRQHandler
USB_HP_CAN1_TX_IRQHandler
USB_LP_CAN1_RX0_IRQHandler
CAN1_RX1_IRQHandler
CAN1_SCE_IRQHandler
EXTI9_5_IRQHandler
TIM1_BRK_IRQHandler
TIM1_UP_IRQHandler
TIM1_TRG_COM_IRQHandler
TIM1_CC_IRQHandler
TIM2_IRQHandler
TIM3_IRQHandler
TIM4_IRQHandler
I2C1_EV_IRQHandler
I2C1_ER_IRQHandler
I2C2_EV_IRQHandler
I2C2_ER_IRQHandler
SPI1_IRQHandler
SPI2_IRQHandler
USART1_IRQHandler
USART2_IRQHandler
USART3_IRQHandler
EXTI15_10_IRQHandler
RTCAlarm_IRQHandler
USBWakeUp_IRQHandler
TIM8_BRK_IRQHandler
TIM8_UP_IRQHandler
TIM8_TRG_COM_IRQHandler
TIM8_CC_IRQHandler
ADC3_IRQHandler
FSMC_IRQHandler
SDIO_IRQHandler
TIM5_IRQHandler
SPI3_IRQHandler
UART4_IRQHandler
UART5_IRQHandler
TIM6_IRQHandler
TIM7_IRQHandler
DMA2_Channel1_IRQHandler
DMA2_Channel2_IRQHandler
DMA2_Channel3_IRQHandler
DMA2_Channel4_5_IRQHandler
                B       .

                ENDP

                ALIGN

;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
                 IF      :DEF:__MICROLIB
                
                 EXPORT  __initial_sp
                 EXPORT  __heap_base
                 EXPORT  __heap_limit
                
                 ELSE
                
                 IMPORT  __use_two_region_memory
                 EXPORT  __user_initial_stackheap
                 
__user_initial_stackheap

                 LDR     R0, =  Heap_Mem
                 LDR     R1, =(Stack_Mem + Stack_Size)
                 LDR     R2, = (Heap_Mem +  Heap_Size)
                 LDR     R3, = Stack_Mem
                 BX      LR

                 ALIGN

                 ENDIF

                 END

;******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE*****

经过技术分析后我们得知这是前几次电子板的启动文件，上边的代码分别实行了一下功能：

首先，定义栈，何为栈？栈是堆栈中的一部分，而堆栈则是为了分配在运行函数时所需分配的内存空间，栈的目的就是将函数从第一行依次录入一个空间，这个空间就是栈；相应的，有栈就要有堆，所以第二段就是定义堆，堆的作用就是从栈中读取函数，同样也是依次读取并将读取的语句存入内存最后由cpu来执行功能。

然后声明中断函数，并根据4字节的长度来分配内存空间，接着编写中断函数的代码。

接下来就到了最重要的一步，将系统时钟函数放入r0寄存器运行完后清除，再将用户程序也就是main放入r0寄存器运行完后清楚，这里可能有人要问了为什么运行完后要清除？因为我们的内存空间是有限的不能无限制让一个已经运行完的程序当钉子户，否则会导致机器越用越卡越用越慢，所以以后在对内存进行操作的时候一定要时刻记得“用完就扔”的原则。

最后就是将用户自己编写的函数放到堆栈中并分配到内存，总共有4个寄存器被分配给了堆栈，r0被分配给了堆的起始地址，r2被分配给了堆的大小，r3被分配给了栈顶指针，r1被分配给了栈的大小。

Stack_Size EQU 0x00000400 
AREA STACK, NOINIT, READWRITE, ALIGN=3 
Stack_Mem SPACE Stack_Size __initial_sp

这三行代码诠释了栈的起始指针和栈的大小：首先将内存中0x00000400声明成了stack_size，再将stack_size（也就是0x00000400)作为内存地址分配给了stack_mem从而达到了设置栈顶指针的目的，再将两者相加就达到了栈的大小。

Heap_Size EQU 0x00000200 
AREA HEAP, NOINIT, READWRITE, ALIGN=3 __heap_base 
Heap_Mem SPACE Heap_Size __heap_limit

那么同理这三行代码诠释了堆的起始地址和堆的大小。

我们查询了这段代码发送的地址，发现是由一个叫均鞭的用户在英国赫里福基地发出的，为了查询事情的真相并找回失踪的指挥官，我！最可爱的人形小狮子将会第一时间赶赴现场为大家带来第一手资讯，请大家继续关注下一期的“小狮子 带侦探”！

 

 

 

发布于

神秘的仪器，新的代码，背后的真相到底是。。。。

欢迎收看今天的“小狮子，带侦探”！上次我们在指挥官的卧室里发现了散发诡异光芒的小灯和一串神秘的代码。今天我们在指挥部后面的小花园里又发现了一个奇怪的装置，这个装置被遗弃在了灌木丛中，但是！我，最可爱的人型s.a.t.8依旧找到了这重要的线索!话不多说，让我们康康今天的带发现吧！

#include "stm32f10x.h"
#include "led.h"
void Delay(uint32_t jun){
  for(;jun!=0;--jun);
}
int main(void){
int a=1,b=0;
  led_gpio_sb();
  led_gpio_yw();
while(1){
  while(a==1){
    if(key_scan(K1_GPIO_PORT,LED_K1_GPIO_PIN)==KEY_ON||b==1){
      led_gpio_config();
      led_gpio_JUN();	
      led_gpio_BIAN();
      while(a==1){		
    LED_G(ON);	 
    LED_B(OFF);	
    LED_R(OFF);
    Delay(0xFFFFF);	
        if(key_scan(K2_GPIO_PORT,LED_K2_GPIO_PIN)==KEY_ON){
      a=0;		
        LED_G(OFF);	 
        LED_B(OFF);
        LED_R(OFF);
      break;}
        LED_G(OFF);	 
        LED_B(ON);
        LED_R(OFF);
        Delay(0xFFFFF);	
        if(key_scan(K2_GPIO_PORT,LED_K2_GPIO_PIN)==KEY_ON){
      a=0;		
        LED_G(OFF);	 
        LED_B(OFF);
        LED_R(OFF);
      break;}
    LED_G(OFF);	 
    LED_B(OFF);
    LED_R(ON);
    Delay(0xFFFFF);	
      if(key_scan(K2_GPIO_PORT,LED_K2_GPIO_PIN)==KEY_ON){
      a=0;		
        LED_G(OFF);	 
        LED_B(OFF);
        LED_R(OFF);
      break;
        }     
      }
    }	
if(a==0) break;
  
  }
    if(key_scan(K1_GPIO_PORT,LED_K1_GPIO_PIN)==KEY_ON){
    a=1;
      b=1;
    
  }
}
}

#include "led.h"
void led_gpio_config(void){
  
  GPIO_InitTypeDef       GPIO_InitStruct;

  RCC_APB2PeriphClockCmd(LED_G_GPIO_CLK, ENABLE);
  
  GPIO_InitStruct.GPIO_Pin=LED_G_GPIO_PIN;
  
  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
  
  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
    
  GPIO_Init(LED_G_GPIO_PORT, &GPIO_InitStruct);
  
}
void led_gpio_JUN(void){
  
  GPIO_InitTypeDef       GPIO_InitStruct;
  
  RCC_APB2PeriphClockCmd(LED_G_GPIO_CLK, ENABLE);
    
  GPIO_InitStruct.GPIO_Pin=LED_B_GPIO_PIN ;
    
  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
  
  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
  
  GPIO_Init(LED_G_GPIO_PORT, &GPIO_InitStruct);
  
}
void led_gpio_BIAN(void){
  
  GPIO_InitTypeDef       GPIO_InitStruct;
  
  RCC_APB2PeriphClockCmd(LED_G_GPIO_CLK, ENABLE);
  
  GPIO_InitStruct.GPIO_Pin=LED_R_GPIO_PIN ;
  
  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
  
  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
  
  GPIO_Init(LED_G_GPIO_PORT, &GPIO_InitStruct);
  
}

void led_gpio_sb(void){
  
  GPIO_InitTypeDef       GPIO_InitStruct;
  
  RCC_APB2PeriphClockCmd(K1_G_GPIO_CLK, ENABLE);
  
  GPIO_InitStruct.GPIO_Pin=LED_K1_GPIO_PIN ;
  
  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IN_FLOATING;
  
  GPIO_Init(K1_GPIO_PORT, &GPIO_InitStruct);
  
}

void led_gpio_yw(void){
  
  GPIO_InitTypeDef       GPIO_InitStruct;
  
  RCC_APB2PeriphClockCmd(K2_G_GPIO_CLK, ENABLE);
  
  GPIO_InitStruct.GPIO_Pin=LED_K2_GPIO_PIN ;
  
  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IN_FLOATING;
    
  GPIO_Init(K2_GPIO_PORT, &GPIO_InitStruct);
  
}

uint8_t key_scan(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin){
  if(GPIO_ReadInputDataBit(GPIOx, GPIO_Pin)==KEY_ON){
    while(GPIO_ReadInputDataBit(GPIOx, GPIO_Pin)==KEY_ON);
    return KEY_ON;
  }
  else return KEY_OFF;
}

#ifndef led_h
#define led_h
#include "stm32f10x.h"
#define LED_G_GPIO_PIN     GPIO_Pin_0
#define LED_R_GPIO_PIN     GPIO_Pin_5 
#define LED_B_GPIO_PIN     GPIO_Pin_1 
#define LED_G_GPIO_PORT    GPIOB
#define K1_GPIO_PORT    GPIOA
#define K2_GPIO_PORT    GPIOC
#define LED_G_GPIO_CLK     RCC_APB2Periph_GPIOB
#define K1_G_GPIO_CLK     RCC_APB2Periph_GPIOA
#define K2_G_GPIO_CLK     RCC_APB2Periph_GPIOC
#define LED_K1_GPIO_PIN     GPIO_Pin_0
#define LED_K2_GPIO_PIN     GPIO_Pin_13
#define ON   1
#define OFF  0
#define LED_G(JUN) if(JUN)GPIO_ResetBits(LED_G_GPIO_PORT, LED_G_GPIO_PIN);else GPIO_SetBits(LED_G_GPIO_PORT, LED_G_GPIO_PIN);
#define LED_B(JUN) if(JUN)GPIO_ResetBits(LED_G_GPIO_PORT, LED_B_GPIO_PIN);else GPIO_SetBits(LED_G_GPIO_PORT, LED_B_GPIO_PIN);
#define LED_R(JUN) if(JUN)GPIO_ResetBits(LED_G_GPIO_PORT, LED_R_GPIO_PIN);else GPIO_SetBits(LED_G_GPIO_PORT, LED_R_GPIO_PIN);
void led_gpio_config(void);
void led_gpio_JUN(void);
void led_gpio_BIAN(void);
void led_gpio_sb(void);
void led_gpio_yw(void);
uint8_t key_scan(GPIO_TypeDef *GPIO,uint16_t GPIO_Pin);
#define KEY_ON 1
#define KEY_OFF 0
#define LED_G_TOGGLE {LED_G_GPIO_PORT->ODR ^=LED_G_GPIO_PIN;}
#define LED_R_TOGGLE {LED_G_GPIO_PORT->ODR ^=LED_R_GPIO_PIN;}
#define LED_B_TOGGLE {LED_G_GPIO_PORT->ODR ^=LED_B_GPIO_PIN;}
#endif

乍一看，这个装置没什么亮点，但是当我们打开开关摁下key1按钮后发现这个装置上的led灯竟然开始闪烁了，当我们再摁下key2按钮后发现led灯竟然熄灭了。这次的发现比上次的更加劲爆，很显然指挥官的失踪并不是无端发生的，这次的装置和上次的装置一定是指挥官留下的线索。后勤官格林娜知道后第一时间来到了现场，在看过代码后，格林娜小姐说这次的代码和上次的有明显的不同，因为上次只有输出而这次却有了输入，通过对输入检测的编写可以让设备接受到信号并作出预先设计好的反应。

格林娜小姐在分析完决定调用格里芬指挥部的力量进行地毯式搜索，想要知道下一次的线索吗？那就继续关注“小狮子，带侦探”吧！我是最可爱的人形s.a.t.8，期待与您分享关于指挥官失踪的第一手资讯。

发布于

JQ8900模块与单片机通信，达到功放效果|基于RTT

上一篇我们已经进行了JQ8900模块的串口调试，这次我们来把它接上单片机来进行调试。

实现了RTT的串口传输16进制数据

-将JQ8900模块上的串口相关线接上开发板

注意串口TX与RX的反接，笔者这里接了开发板上的UART2接口，分别是PA2（TX），PA3（RX）。

接下来进行程序的编写，我们根据JQ8900的串口手册，相关定义如下

我们进行最简单的播放测试，即01条

以下是测试代码：

/*
通过RTT例子修改
用于测试JQ8900是否可用
*/

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


#define SAMPLE_UART_NAME       "uart2"

static rt_device_t serial;              /* 串口设备句柄 */
struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT; /* 配置参数 */


/* 用于接收消息的信号量 */
static struct rt_semaphore rx_sem;
static rt_device_t serial;

/* 接收数据回调函数 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    /* 串口接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
    rt_sem_release(&rx_sem);

    return RT_EOK;
}




static void serial_thread_entry(void *parameter)
{
  //  char ch;
    int jun = 1;
    while (1)
      
    {		
             /*发送缓冲区是固定为5个字节长度的*/
        static char uart2_tx_buffer[5]={0xAA,0x02,0x00,0xAC,0x05};//测试字段，作用为播放当前音乐
        rt_uint32_t tx_length;
        tx_length=5;
        if(jun){
        rt_device_write(serial,0,&uart2_tx_buffer[0],tx_length);
        rt_device_write(serial,0,&uart2_tx_buffer[1],tx_length);
        rt_device_write(serial,0,&uart2_tx_buffer[2],tx_length);
        rt_device_write(serial,0,&uart2_tx_buffer[3],tx_length);
        rt_kprintf("device message sent!");}
        /* 从串口读取一个字节的数据，没有读取到则等待接收信号量 */						
             jun = 0;
    }
}

static int mdr1(int argc, char *argv[])
{
    rt_err_t ret = RT_EOK;
    char uart_name[RT_NAME_MAX];

    if (argc == 2)
    {
        rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
    }
    else
    {
        rt_strncpy(uart_name, SAMPLE_UART_NAME, RT_NAME_MAX);
    }

    /* 查找系统中的串口设备 */
    serial = rt_device_find(uart_name);

    rt_device_control(serial, RT_DEVICE_CTRL_CONFIG, &config);
    if (!serial)
    {
        rt_kprintf("find %s failed!\n", uart_name);
        return RT_ERROR;
    }

    /* 初始化信号量 */
    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
    /* 以中断接收及轮询发送模式打开串口设备 */
    rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
    config.baud_rate = BAUD_RATE_9600;    //配置串口通信为9600
    config.data_bits = DATA_BITS_8;
    config.stop_bits = STOP_BITS_1;
    config.parity = PARITY_NONE;
    /* 打开设备后才可修改串口配置参数 */
    rt_device_control(serial, RT_DEVICE_CTRL_CONFIG, &config);
    /* 设置接收回调函数 */
    rt_device_set_rx_indicate(serial, uart_input);

    /* 创建 serial 线程 */
    rt_thread_t thread = rt_thread_create("serial", serial_thread_entry, RT_NULL, 1024, 25, 10);
    /* 创建成功则启动线程 */
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }
    else
    {
        ret = RT_ERROR;
    }

    return ret;
}
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(mdr1, uart JUN);

 

代码简要解析

  1. 打开并配置了串口通信为9600，数据位为8，停止位为1
  2. 设置的回调函数中使用了一个数组用来储存16进制，HEX数据
  3. 使用rt_device_write函数分4次把一个完整的命令传输到JQ8900
  4. 实现了串口通信

将本页代码添加到您的RTT-BSP中，编译后进行烧录，通过msh发送mdr1

 \ | /
- RT -     Thread Operating System
 / | \     4.0.2 build Aug 22 2019
 2006 - 2019 Copyright by rt-thread team
msh />mdr1
msh />device message sent!

 

即可听到JQ8900喇叭的声音，测试成功

 

发布于

S09区指挥官临阵脱逃竟然去干了这种事情，男人看了沉默，女人看了流泪。

这里是s.a.t.8为您带来的关于指挥官临阵脱逃的第一手资讯。今天一整天，别的指挥官都在忙着和白色势力作斗争但是我们的指挥官却失踪了，经过我们的搜索发现在指挥官办公桌上发现了一串神奇的代码

typedef unsigned int uint32_t;
typedef struct {
uint32_t CRL;
uint32_t CRH;
uint32_t IDR;
uint32_t ODR;
uint32_t BSRR;
uint32_t BRR;
uint32_t LCKR;
}GPIO
#define JUN ((GPIO*)GPIOB)

 

 

没有人知道这是什么意思，但我们在旁边找到一些字迹好像是指挥官自己亲手写的：“在对stm32进行编程的时候可以使用自己预先写好的寄存器结构体来进行编程，这种方法和昨天使用的直接使用寄存器编程有一定的区别，这是一种新的技术还需多多使用才能把它牢固地掌握。在今天的研究中发现在使用此方法时需要注意在定义结构体的名字时要将名字定义在大括号下面否则就要再定义一个别名。使用define时切忌不要加分号“；”否则会报错（因为这个问题困扰了我整整1个小时）。”

这是指挥官在这段代码旁留下的语句，我们不知道这有什么确切的含义，但有一点肯定的是指挥官正在进行一些秘密研究。

s.a.t.8会继续跟进这个事件，想要知道真相的人形们一定要第一时间收看我们的“小狮子 带侦探”哦！

 

发布于

s.a.t.8的学习小结

经过一下午的奋斗(确 信)，总于让stm32开发板上的led亮起来了!!!但是在编程中发现一个很大的van题，那就是如果不写void systeminit (void){}，程序就会报错导致根本下载不了(因为这个问题我花了近两个小时时间，期间还一度以为是软件没有装好重新去下了一遍。。。。最后靠着一位带佬成功解决了van题)

最后说一句 小狮子天下第一!