在前面的几个章节中我们介绍了关于MM32F0130系列的ClassB 认证的实现方式，本章节中我们将为大家介绍在MM32F0130上ClassB认证的各部分代码段测试所花费的时间。

ClassB认证的各部分代码段运行都会增加MCU的负担，为防止认证代码影响应用控制，我们需要对各个部分代码执行时间进行测试，分时段利用时间空隙进行自检。耗时与很多因素有关系，MCU的性能和开发环境都会有影响，在单次运行中执行启动测试，测试时间取决于MCU性能和测试区的大小。运行期间测试逐块执行，因此其时间也取决于被测试块大小和测试的重复频率。

用户需要在应用所需的性能和安全认证所需的性能之间找到平衡，主要挑战在于实现较短的整体诊断测试间隔，同时保持应用过程安全时间在可接受的长度范围内。在关键情况下，运行时测试可限制在收集关键代码或数据的区域。

用户应考虑到该间隔也用于在运行期间计算系统时钟和LSI之间的时钟交叉参考率，因而其长度不得低于时钟交叉测量所用的LSI周期数相应间隔。

当特定测试（RAM、Flash、时钟）启动时及每次完成测试程序（启动时和运行期间）时，通过切换I/O的翻转来测试各个部分的耗时。其中，在启动时和运行期间，这些I/O可用于测量测试长度、局部测试的频率及完成整个单测试周期所需的时间。完全检测被测试的专用区域后，一组局部测试又重新开始。

在ClassB自检的过程中，ClassB自检流程分为启动自检与运行自检两个部分，本次例程我们将采用翻转GPIO口的方式来测试ClassB启动自检以及运行自检所花费的时间。

本次测试我们翻转PA0来进行计算时间(即在自检之前设置为低电平，自检完成以后设置为高电平，然后使用逻辑分析仪抓取低电平的持续时间即为自检部分花费的时间)。

启动自检

启动自检部分包含CPU寄存器自检，看门狗自检，FLASH自检，RAM自检以及时钟自检，启动自检的流程如下图所示：

01、CPU寄存器自检

CPU寄存器自检调用的函数为STL_StartUpCPUTest()， 在此函数之前我们调用GPIO的配置函数，将PA0配置为低电平，在函数运行完成后将PA0配置为高电平，然后使用逻辑分析仪抓取两次电平翻转的脉宽即可，逻辑分析仪获取波形如下：

由上图可以看出CPU寄存器的启动自检的时间为12.51us。

02、看门狗自检

看门狗自检调用的函数为STL_WDGSelfTest() ，在此函数中进行PA0的翻转设置，其操作与CPU寄存器的操作一样，但是我们需要屏蔽掉CPU寄存器自检操作过程中PA0的翻转操作（由于本次测试的内容较多，为了防止计算错误，故一个一个的测试）。

由上述逻辑分析仪抓取的波形可知看门狗自检花费的时间为3.591ms。

03、FLASH自检

FALSH自检操作在FLASH自检的地方对GPIO口进行翻转操作，逻辑分析仪获取波形如下：

由逻辑分析仪抓取的波形可知64K的FLASH自检的时间为9.36ms，其中包含CRC校验等耗费的时间。

04、RAM自检

RAM自检操作在RAM自检的地方对GPIO口进行翻转操作，逻辑分析仪获取波形如下：

由上图可知16K的RAM启动自检花费的时间为1.1ms。

05、时钟自检

时钟自检操作在时钟自检的地方对GPIO口进行翻转操作，具体操作如下：

由上图可知在启动时时钟自检花费的时间为9.37ms。

运行自检

运行自检耗时的测试方法与启动自检的方法一致，也是通过翻转GPIO来实现的。

运行自检周期直接调用函数STL_DoRunTimeChecks（）函数即可，在函数中包含了所有的运行自检的流程，下面我们来测试运行自检花费的时间。

测试运行自检周期如下所示：

由上图可知，官方例程设置自检周期的时间为10.008ms。

测试CPU寄存器运行自检所花费的时间如下所示：

由上图可知CPU寄存器运行自检的时间为10.18us。

运行期间的测试逐块执行，因此其时间也取决于被测试块大小和测试的重复频率，同时开发环境也影响执行效率，使用IAR和MDK开发的执行时间也有差异，本次实验系统时钟设置48MHz，基于MDK5.27版本的工程测试得出的数据。

对算法在运行时间和存储空间这两种资源的利用效率进行研究是一门学问，研究如何用更小的空间、更短的时间完成所需要的功能是一件很有意思的工作，有兴趣的可以深入研究一下。

来源：灵动微电子
免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

在上一章节中我们介绍了RAM检测的实现方法，本章节我们将给大家介绍FLASH检测的实现方法。

测试Flash存储器完整性时，需要用到CRC校验，在参考代码中我们使用了硬件的CRC单元，通过硬件CRC生成器完成的CRC计算大大降低CPU负载。

Flash存储器测试的范围由用户界定，在运行时，如果整个内存范围因测试时间太长而不能接受，用户可将其分成若干片段，Flash存储器测试范围由用户界定，我们需要对被测试区域进行动态修改，以便在那些区域单独执行测试。

检查区域的边界必须与测试中用到的多重测试块的大小一致。根据mm32_STLparam.h文件中定义的参数FLASH_BLOCK_WORDS，块大小默认设为16字（ 64字节），检查中未使用的内存区域可通过预定义值来识别。

我们会将CRC校验值存储在某一个地址，然后将CRC计算结果与相应的参考值进行比较，参考模式可由编译器（ IAR™）自动提供或由在外部计算后由最终用户添加（ MDK-ARM®和AC6）。

在ClassB检测中，Flash存储器检测也分为启动自检与运行自检两部分。

启动时对FLASH的检测方法：

• 编译时计算整个FLASH的CRC校验值，并存储在FLASH末尾位置
• 启动时，用同样的算法重新计算整个FLASH的CRC校验值（不包括前面存储在FLASH中的CRC校验值），并与存储在FLASH中的CRC校验值做比较

函数为：

void STL_StartUp(void);

运行时对FLASH的检测方法：

• 对FLASH分块逐次计算出最终的CRC校验值
• 将最终结果与正确的CRC校验值做比较

函数为：

ClassBTestStatus STL_crc32Run(void);

01、FLASH验证方法

FLASH的验证分为2个步骤，如下所示：

1. 读取PC端计算FLASH对应的CRC值。

2. MCU运行计算出来的CRC值与读取到的PC端计算的CRC值进行比较。

1.1、设置IAR生成CRC

1）IAR可以很方便的支持在编译时计算CRC32，并存储在FLASH指定位置。

Fill unused code memory：定义了FLASH中需要计算CRC的范围和空闲字节填充值；

Checksum size：选择checksum的大小（字节数）；

Alignment：指定checksum的对齐方式，不填的话默认2字节对齐；

Algorithm：选择checksum的算法；

Complement：是否需要进行补码计算，选择“As is”就是不进行补码计算；

Bit order：位输出的顺序，MSB first，每个字节的高位在前；LSB first，每个字节的低位在前；

Reverse byte order within word：对于输入数据，在一个字内反转各个字节的顺序；

Initial value：checksum计算的初始化值；

Checksum unit size：选择进行迭代的单元大小，按8-bit，16-bit还是32-bit进行迭代。

2）指定checksum在FLASH中的存储位置——修改linker文件：

place at end of ROM_region { ro section .checksum };

1.2、设置Keil生成CRC脚本

在Keil中需要单独计算CRC的值，并手动添加代码将其放在FLASH末尾。

当MDK在工程编译完成以后会在option for target ->User页面下面，勾选After build/Rebuild中的Run#1选项，则会在工程编译完成以后执行After build/Rebuild中的Run#1选项后面User Command路径选择中选择的脚本（crc_gen_keil.bat脚本）。

SREC_PATH：设定工具路径；

TARGET_NAME：生成Hex文件名；

MAP_FILE：原始生成的map文件；

INPUT_FILE：原始生产的HEX文件；

OUTPUT_FILE：计算CRC后的CRC文件；

crc_gen_keil.bat脚本内容：

REM Path configuration
SET SREC_PATH=C:\SREC
SET TARGET_NAME=CLASSBTEST
SET TARGET_PATH=OBJ
SET BYTE_SWAP=1
SET COMPARE_HEX=1
SET CRC_ADDR_FROM_MAP=1
REM Not used when CRC_ADDR_FROM_MAP=1
SET CRC_ADDR=0x08007ce0

执行SET批处理命令，将相关的文件赋值给相对应的变量。

REM Derived configuration
SET MAP_FILE=%TARGET_PATH%\%TARGET_NAME%.map
SET INPUT_HEX=%TARGET_PATH%\%TARGET_NAME%.hex
SET OUTPUT_HEX=%TARGET_PATH%\%TARGET_NAME%_CRC.hex
SET TMP_FILE=crc_tmp_file.txt

通过srec_cat.exe工具查找map文件中的__check_sum地址，并把计算的新的CRC的值填入到这个地址。

1.3、在启动文件中设置CRC校验

AREA    CHECKSUM, DATA, READONLY, ALIGN=6
    EXPORT  __Check_Sum
    ALIGN
   __Check_Sum     DCD     0x8A7A061D;                
   END

1.4、配置硬件CRC

MM32的CRC初始化配置较简单，使能CRC时钟，复位 CRC 计算单元即可。

RCC_AHBPeriphClockCmd(RCC_AHBENR_CRCEN,ENABLE);
CRC_ResetDR();

计算CRC的数值：

 for(index = 0; index < (uint32_t)ROM_SIZEinWORDS; index++)
  {
    CRC->DR = __REV(*((uint32_t *)ROM_START + index));
  }
  crc_result = CRC->DR;

02、MCU运行中计算FLASH中的CRC

把要计算的FLASH大小分成多块累计计算CRC。

uint32_t index;

for(index = 0; index < (uint32_t)FLASH_BLOCK_WORDS; index++)
  {
    CRC->DR = __REV(*(pRunCrc32Chk + index));
   }
  pRunCrc32Chk += FLASH_BLOCK_WORDS; 
  pRunCrc32ChkInv = ((uint32_t *)~((uint32_t)pRunCrc32Chk));

  result = TEST_RUNNING;

2.1 MCU运行中计算的CRC的数值与PC端计算的CRC数值进行比较

如果两者计算的CRC的数值相同则FLASH验证通过，否则验证失败。

启动时对比结果：

#if defined(__CC_ARM) || defined(__GNUC__) 
    if(crc_result != *(uint32_t *)(&REF_CRC32))
  #endif 
    {
      #ifdef STL_VERBOSE_POR
        printf("FLASH 32-bit CRC Error at Start-up\n\r");
      #endif  /* STL_VERBOSE_POR */
        FailSafePOR();    //for ROM test  realse must  open;
        //control_flow_resume(CRC_TEST_CALLER);  
    }
    else
    { /* Test OK */
      #ifdef STL_VERBOSE_POR
        printf(" Start-up FLASH 32-bit CRC OK\n\r");
      #endif  /* STL_VERBOSE_POR */

      control_flow_resume(CRC_TEST_CALLER);  
    }

运行时对比结果：

if(CRC->DR == *(uint32_t *)(&REF_CRC32))
{
   result = TEST_OK;
}
else
{                   
   //result = TEST_OK ;     //  for ROM test  realse must  open;*******
   result = TEST_FAILURE;
}

如果该块的FLASH检测通过，则进行下一次的检测，循环这一个过程。

至此，FLASH的校验已经全部完成，具体的配置程序可以参考官网例程。

来源：灵动微电子
免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

在上一章节中我们介绍了主要介绍了ClassB软件的作用、框架和流程等，本章节将给大家介绍CPU寄存器检测实现方法。

01、CPU寄存器自检

R0 ~ R12我们称为通用寄存器，其中寄存器R0 ~ R7我们称为低寄存器，寄存器R8 ~ R12我们称为高寄存器，可用于数据操作。

在对R0 ~ R12寄存器进行操作时需要注意：绝大多数 16 位 Thumb 指令只能访问 R0‐R7，而 32 位 Thumb‐2 指令可以访问所有寄存器。

R13作为堆栈指针 SP，SP有两个：

主堆栈指针(MSP)：复位后缺省使用的堆栈指针，用于操作系统内核以及异常处理例程（包括中断服务例程）。

进程堆栈指针(PSP)：由用户的应用程序代码使用。

R14连接寄存器：当呼叫一个子程序时，由 R14 存储返回地址。

CPU自检在启动时和运行时都会进行，在启动时，所有寄存器(R0~R12，PSP，MSP)和标记的功能测试都会进行一次自检；运行时，周期性自检，不检测R13，R14，仅检测寄存器R0~R12。

02、CPU寄存器测试原理

在mm32_cpu_startKeil.s与mm32_cpu_runKeil.s文件中会对CPU寄存器进行测试，其中mm32_cpu_startKeil.s文件中的测试为启动过程中对CPU寄存器进行的测试，mm32_cpu_runKeil.s文件中的测试为运行自检流程中的CPU寄存器测试，其原理为对寄存器每一位写0和写1操作，对比是否有错误。

具体实现：分别写入0xAAAAAAAA和0x55555555再进行比较是否为写入的值。

03、CPU寄存器测试实现

以启动时CPU自检程序为例进行分析，将conAA数据定义为0xAAAAAAAA，将con55定义为0x55555555，并使用EXPORT指令进行声明。

conAA       DCD     0xAAAAAAAA
con55       DCD     0x55555555 
con80       DCD     0x80000000
conA8       DCD     0xAAAAAAA8
con54       DCD     0x55555554

EXPORT conAA
EXPORT con55

声明函数ClassB_StartUpCPUTest函数，并进行CPU寄存器中的R1寄存器的检测，先将conAA的数据赋值给R0寄存器，然后赋值给R1寄存器，然后比较R0与R1寄存器的数据，如果两者的数据相同则将con55分别赋值给R1与R0寄存器进行比较，否则会跳转执行CPUTestFail函数，如果两者的数据相同则将0x01赋值给R1寄存器，否则将会跳转到CPUTestFail函数中。

    ; Register R1
    LDR R0, =conAA
    LDR R1,[R0]
    LDR R0,[R0]
    CMP R0,R1
    BNE CPUTestFail
    LDR R0, =con55
    LDR R1,[R0]
    LDR R0,[R0]
    CMP R0,R1
    BNE CPUTestFail
    MOVS R1, #0x1             ; For ramp test

在汇编程序中大家可以看到，如果检测失败，会跳转到CPUTestFail函数执行，如果检测成功则进行下一步的检测。

依次针对R2 ，R3，R4，R5，R6，R7，R8，R9，R10，R11，R12寄存器进行与R1一样的操作，在上述的寄存器比较完成以后相应的寄存器会被赋予新的数据。

Class_StartUpCPUTest PROC
      EXPORT Class_StartUpCPUTest

    PUSH {R4-R6}              ; Safe critical registers

    MOVS R0, #0x00            
    UXTB R0,R0
    ADDS R0,#0                            ; Set Z(ero) Flag
    BNE CPUTestFail        ; Fails if Z clear
    BMI CPUTestFail        ; Fails if N is set
    SUBS R0,#1             ; Set N(egative) Flag
    BPL CPUTestFail        ; Fails if N clear
    ADDS R0,#2              ; Set C(arry) Flag and do not set Z
    BCC CPUTestFail         ; Fails if C clear
    BEQ CPUTestFail         ; Fails if Z is set
    BMI CPUTestFail         ; Fails if N is set

    LDR R0,=con80                 ; Prepares Overflow test
    LDR R0,[R0]
    ADDS R0, R0, R0          ; Set V(overflow) Flag
    BVC CPUTestFail          ; Fails if V clear

    ; This is for control flow test (ENTRY point)
    LDR R0,=CtrlFlowCnt
    LDR R1,[R0]
    ADDS R1,R1,#0x3             ; CtrlFlowCnt += OxO3
    STR R1,[R0]

    ; Register R1
    LDR R0, =conAA
    LDR R1,[R0]
    LDR R0,[R0]
    CMP R0,R1
    BNE CPUTestFail
    LDR R0, =con55
    LDR R1,[R0]
    LDR R0,[R0]
    CMP R0,R1
    BNE CPUTestFail
    MOVS R1, #0x1             ; For ramp test

    ; Register R2
    LDR R0, =conAA
    LDR R2,[R0]
    LDR R0,[R0]
    CMP R0,R2
    BNE CPUTestFail
    LDR R0, =con55
    LDR R2,[R0]
    LDR R0,[R0]
    CMP R0,R2
    BNE CPUTestFail
    MOVS R2, #0x2             ; For ramp test

    ; Register R3
    LDR R0, =conAA
    LDR R3,[R0]
    LDR R0,[R0]
    CMP R0,R3
    BNE CPUTestFail
    LDR R0, =con55
    LDR R3,[R0]
    LDR R0,[R0]
    CMP R0,R3
    BNE CPUTestFail
    MOVS R3, #0x3             ; For ramp test

    ; Register R4
    LDR R0, =conAA
    LDR R4,[R0]
    LDR R0,[R0]
    CMP R0,R4
    BNE CPUTestFail
    LDR R0, =con55
    LDR R4,[R0]
    LDR R0,[R0]
    CMP R0,R4
    BNE CPUTestFail
    MOVS R4, #0x4             ; For ramp test

    ; Register R5
    LDR R0, =conAA
    LDR R5,[R0]
    LDR R0,[R0]
    CMP R0,R5
    BNE CPUTestFail
    LDR R0, =con55
    LDR R5,[R0]
    LDR R0,[R0]
    CMP R0,R5
    BNE CPUTestFail
    MOVS R5, #0x5             ; For ramp test

    ; Register R6
    LDR R0, =conAA
    LDR R6,[R0]
    LDR R0,[R0]
    CMP R0,R6
    BNE CPUTestFail
    LDR R0, =con55
    LDR R6,[R0]
    LDR R0,[R0]
    CMP R0,R6
    BNE CPUTestFail
    MOVS R6, #0x6             ; For ramp test

    ; Register R7
    LDR R0, =conAA
    LDR R7,[R0]
    LDR R0,[R0]
    CMP R0,R7
    BNE CPUTestFail
    LDR R0, =con55
    LDR R7,[R0]
    LDR R0,[R0]
    CMP R0,R7
    BNE CPUTestFail
    MOVS R7, #0x7             ; For ramp test

    ; Register R8
    LDR R0, =conAA
    LDR R0,[R0]
    MOV R8,R0
    CMP R0,R8
    BNE CPUTestFail
    LDR R0, =con55
    LDR R0,[R0]
    MOV R8,R0
    CMP R0,R8
    BNE CPUTestFail
    MOVS R0, #0x08            ; For ramp test
    MOV    R8,R0

    BAL CPUTstCont

CPUTestFail
    BLAL FailSafePOR

CPUTstCont
    ; Register R9
    LDR R0, =conAA
    LDR R0,[R0]
    MOV R9,R0
    CMP R0,R9
    BNE CPUTestFail
    LDR R0, =con55
    LDR R0,[R0]
    MOV R9,R0
    CMP R0,R9
    BNE CPUTestFail
    MOVS R0, #0x09            ; For ramp test
    MOV    R9,R0

    ; Register R10
    LDR R0, =conAA
    LDR R0,[R0]
    MOV R10,R0
    CMP R0,R10
    BNE CPUTestFail
    LDR R0, =con55
    LDR R0,[R0]
    MOV R10,R0
    CMP R0,R10
    BNE CPUTestFail
    MOVS R0, #0x0A            ; For ramp test
    MOV    R10,R0

    ; Register R11
    LDR R0, =conAA
    LDR R0,[R0]
    MOV R11,R0
    CMP R0,R11
    BNE CPUTestFail
    LDR R0, =con55
    LDR R0,[R0]
    MOV R11,R0
    CMP R0,R11
    BNE CPUTestFail
    MOVS R0, #0x0B            ; For ramp test
    MOV    R11,R0

    ; Register R12
    LDR R0, =conAA
    LDR R0,[R0]
    MOV R12,R0
    CMP R0,R12
    BNE CPUTestFail
    LDR R0, =con55
    LDR R0,[R0]
    MOV R12,R0
    CMP R0,R12
    BNE CPUTestFail
    MOVS R0, #0x0C            ; For ramp test
    MOV    R12,R0
    LDR R0, =CPUTstCont

R1~R12寄存器比较完成以后会在Ramp中做进一步的判断，判断R1寄存器的数值是否为0x01，R2寄存器的数值是否为0x02，依次判断到R12寄存器，如果以上的判断都是正确的则说明R1~R12寄存器验证通过。

 ; Ramp pattern verification    (R0 is not tested)
    CMP R1, #0x01
    BNE CPUTestFail
    CMP R2, #0x02
    BNE CPUTestFail
    CMP R3, #0x03
    BNE CPUTestFail
    CMP R4, #0x04
    BNE CPUTestFail
    CMP R5, #0x05
    BNE CPUTestFail
    CMP R6, #0x06
    BNE CPUTestFail
    CMP R7, #0x07
    BNE CPUTestFail
    MOVS R0, #0x08
    CMP R0,R8
    BNE CPUTestFail
    MOVS R0, #0x09
    CMP R0,R9
    BNE CPUTestFail
    MOVS R0, #0x0A
    CMP R0,R10
    BNE CPUTestFail
    MOVS R0, #0x0B
    CMP R0,R11
    BNE CPUTestFail
    MOVS R0, #0x0C
    CMP R0,R12
    BNE CPUTestFail

对R13的自检功能与通用寄存器的操作不同，需要先保存堆栈到R0，操作如下：

   ; Process Stack pointer (banked Register R13)
    MRS R0,PSP          ; Save process stack value

    LDR R1, =conA8      ; Test is different (PSP is word aligned, 2 LSB cleared)
    LDR R1,[R1]
    MSR PSP,R1          ; load process stack value
    MRS R2,PSP          ; Get back process stack value
    CMP R2,R1           ; Verify value
    BNE CPUTestFail

    LDR R1, =con54      ; Test is different (PSP is word aligned, 2 LSB cleared)
    LDR R1,[R1]
    MSR PSP,R1          ; load process stack value
    MRS R2,PSP          ; Get back process stack value
    CMP R2,R1           ; Verify value
    BNE CPUTestFail

    MSR PSP, R0         ; Restore process stack value

    ; Stack pointer (Register R13)
    MRS R0,MSP          ; Save stack pointer value

    LDR R1, =conA8      ; Test is different (SP is word aligned, 2 LSB cleared)
    LDR R1,[R1]
    MSR MSP,R1            ; load SP value
    MRS R2,MSP            ; Get back SP value
    CMP R2,R1            ; Verify value
    BNE CPUTestFail

    LDR R1, =con54
    LDR R1,[R1]            ; load SP value
    MSR MSP,R1            ; Get back SP value
    MRS R2,MSP            ; Verify value
    CMP R2,R1
    BNE CPUTestFail

    MSR MSP,R0            ; Restore stack pointer value

    ; Control flow test (EXIT point)
    LDR R0,=CtrlFlowCntInv
    LDR R1,[R0]
    SUBS R1,R1,#0x3        ; CtrlFlowCntInv -= OxO3
    STR R1,[R0]

    POP {R4-R6}            ; Restore critical registers

    ; If next instruction is not executed, R0 will hold a value different from 0
    MOVS R0, #0x1       ; CPUTEST_SUCCESS
    BX LR               ; return to the caller

    ALIGN

    ENDP

  END

以上代码是在启动时CPU寄存器自检的汇编代码，在运行时CPU寄存器自检功能与启动自检的代码原理相同，只是对寄存器操作个数有差异，运行时不用对R13\14进行操作。

在汇编程序中我们会使用CMP指令进行判断，后面会跟着BNE指令，其作用就是判断如果CMP判断的两个寄存器不相等，则直接执行BNE指令后面的CPUTestFail函数，直接提醒错误报警，或可以添加对应的处理机制。

来源：灵动微电子
免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

JDK：
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

JDK是Eclipse的必要运行环境，本次实验使用的是jdk-8u231-linux-x64.tar.gz。

Eclipse：

https://www.eclipse.org/downloads/packages/

Eclipses根据开发语言选择合适的安装包，我们主要用C/C++开发，使用的是
Eclipse IDE for C/C++ Developers linux 64-bit。

注：安装包版本可自行选择，但要注意一点，新版本的eclipse可能会与低版本的JDK不兼容。

2.2、JAVA环境

在/opt文件夹下新建一个jvm目录，将解压后得到的jdk1.8.0_231（取决于JDK版本）移动到新建的jvm目录下，添加java路径后，在终端中键入命令。

sudo mkdir /opt/jvm
sudo gedit .profile

在文件最后添加如下内容。（JDK版本号可能有所不同，文件夹的名称由实际的文件夹名称为准）

# java path
export JAVA_HOME=/opt/jvm/jdk1.8.0_231
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH

最后键入命令使得路径生效。

source .profile

此时，在终端中键入java版本查看命令。

java -version

如果出现如下信息,，则说明JAVA环境配置成功。

2.3、安装Eclipse

解压eclipse的软件包会得到一个eclipse的文件夹，将其移动到/opt目录下，建立jre软连接。

sudo mkdir /opt/eclipse/jre
sudo ln -s /opt/jvm/jdk1.8.0_231/bin /opt/eclipse/jre/

添加eclipse的桌面图标。

sudo gedit /usr/share/applications/eclipse.desktop

在打开的文件中键入。（注意Exe和Icon路径是否正确）

[Desktop Entry]
Encoding=UTF-8
Name=Eclipse
Comment=Eclipse
Exec=/opt/eclipse/eclipse 
Icon=/opt/eclipse/icon.xpm
Terminal=false
StartupNotify=true
Type=Application
Categories=Application;Development;

接着ctrl+s保存文件，然后赋予可执行权限。

sudo chmod u+x /usr/share/applications/eclipse.desktop

最后将eclipse.desktop复制到桌面或者固定在dock上，后面就可以通过图标启动eclipse。

2.4、安装交叉编译链arm-none-eabi-gcc

我们从ARM官方选择合适的版本下载（此处选择了Linux64）：

https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads

下载的为tar.ba2格式压缩包，使用命令tar -jxf <要解压的文件>解压到我们要安装的目录：

为了以后使用方便，将文件夹重命名：

它下面的bin目录就是我们要使用的编译工具链：

接下来我们要将bin目录添加到环境变量，这样可以直接在命令行输入要使用的工具名，然后系统就可以找到该工具，在此我们仅为当前用户添加环境变量，使用gedit ~/.bashrc编辑当前用户配置文件，在文件最后添加：

export PATH=$PATH:/home/neomissing/gcc-arm-none-eabi/bin

然后使用命令source ~/.bashrc更新系统路径，使添加的环境变量立即生效：

然后输入命令arm-none，然后按三下Tab（一定不要输入全部），检查系统是否可以自动补全。如果系统可以提示，说明环境变量配置成功，可以放心使用arm-none-eabi工具链。

2.5、安装GNU ARM Eclipse插件包

The recommended way to install these plug-ins is to use the Eclipse standard install/update mechanism: In the Eclipse menu: Help → Install New Software…
in the Install window, click the Add… button (on future updates, just select the URL in theWork with: combo)
fill in Name: with GNU ARM Eclipse Plug-ins
fill in Location:
with http://gnuarmeclipse.sourceforge.net/updates

click the Add button
normally the main window should list a group named CDT GNU Cross Development Tools; expand it select all the plug-ins (the one marked End of life is needed only for compatibility with previous version, normally can be safely skipped)
click the Next button and follow the usual installation procedure

Once you define the update site URL, further updates are greatly simplified (Help → Check For Updates)。

2.6、安装OpenOCD

安装openocd 打开Ubuntu终端（alt+ctrl+t）输入命令：

sudo apt install openocd

完成之后 输入openocd查看版本信息。

目前默认安装的openocd芯片支持不全，找到openocd安装路径删除，复制替换MindMotion提供的openocd即可。

检查MM32 DAP-Link连接正常。

打开Ubuntu终端（alt+ctrl+t）输入lsusb，查看连接如下：

03、创建MM32工程并配置、编译、调试

3.1、工程创建

打开eclipse，创建一个c工程，点击file，新建New Project，选择C Project。

点击next，输入工程名字test，如下配置：

连续点击next。

选择选择工具链路径，这一路径就是我们第二步中arm-none-eabi-gdb的路径，需要匹配，点击finish。

添加自己的工程文件，然后指定头文件路径以及配置路径，在工程浏览器中选中工程，右键单击选择Properties，再选择C/C++ Build-->Settings，跳出如下界面：

配置汇编器Cross ARM GNU Assembler，主要是添加预处理宏：

配置编译器Cross ARM C Compiler，添加预处理宏。

添加头文件搜索目录。

配置连接器 Cross ARM C Linker，主要是选择连接脚本文件。

3.2、编译工程

选择Project-> Build Project选项来编译整个工程。

3.3、连接目标板

在eclipse中配置openocd，连接目标板。点击External Tools Configurations，双击Program选项。

然后打开终端输入如下命令 which openocd，找可执行文件openocd的路径，然后把路径复制到Location一栏，在Arguments一栏中输入如下配置信息：

-f /usr/share/openocd/scripts/interface/cmsis-dap.cfg
-f /usr/share/openocd/scripts/target/mm32f013x.cfg

其中的mm32f013x.cfg需要根据你的目标板上的MCU不同而会改变。

此配置文件路径是安装openocd通过命令sudo apt install openocd安装的，是系统默认路径。如果用户在此路径中找不到相关文件，那么请自行查找与修改路径。

然后点击Apply，Run后会在窗口出现信息，表示连接成功。

3.4、Debug调试

配置debug环境：点击Debug Configurations选项，双击GDB OpenOCD Debugging在窗口点击Debugger一栏。

分别修改如下三个窗口的内容，第一个为可执行openocd命令所在路径，第二个为openocd连接DAP-Link与目标板的命令，第三个为工具链arm-none-eabi-gdb等所在的路径。

点击Apply，Debug就可以开始调试。

来源：灵动微电子
免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。

在实际项目中，很多时候，我们需要将传感器、ADC的数值和计算的结果变量以波形的形式显示。通常的解决办法是用串口上位机、USB接口上位机或者MDK的逻辑分析仪等方式输出查看，使用这三种方式都比较繁琐，需要占用额外的系统资源。今天为大家讲解的J-Scope波形软件简单易用，不占用系统额外资源，无需用户写目标板代码，仅需将JLINK插上即可。

针对以上的问题，SEGGER推出了J-Scope波形显示软件。

J-Scope上位机

J-Scope是SEGGER公司推出的，可以在目标MCU运行时，实时分析数据并图形化显示的软件。它不需要SWO或目标上的任何额外引脚等功能，使用标准的调试接口即可。J-Scope波形显示软件主要有RTT和HSS两种工作方式。

01、HSS模式

HSS模式不需要在用户代码上面添加任何代码即可实现。只需要使用J-Scope加载MDK或者IAR的可执行文件即可（MDK生成的可执行文件为.axf文件，IAR生成的文件为.out文件），而且随时随地都可以连接目标板，不影响目标板的正常功能，不需要额外资源，同时可以设置上升沿，下降沿或者双沿触发。

02、RTT模式

RTT快速上传模式，需要用户在代码上加入RTT的相关组件（相关组件的添加请参考上一章节），并使用J-Link与目标板连接，此模式采用标准的下载接口，用到的下载接口有VCC、GND、SWDIO、SWCLK、RST。

03、J-Scope在HSS模式下支持的产品型号

04、JScope在RTT模式下支持的产品型号

05、不同版本的J-Link速度对比

HSS模式获取数据

HSS模式比较简单，仅需要将编译器生成的可执行文件加入到J-Scope上位机软件即可。

相对于RTT模式来说此模式随时随地都可以连接目标板，并且不影响目标板的正常功能，并且不需要额外的资源。但是相对于RTT模式也存在着速度慢的缺点，采样的速度基本上在1KHZ左右，仅适合采样变量变化速度低于1KHZ的情况。

01、HSS模式使用方法

将目标板与J-Link连接，下载程序后并重新上电。

打开J-Scope的上位机软件，如下图所示：

创建工程，选择“Create new project”选项，弹出工程配置对话框。

J-Link使用的为USB接口，所以在进行配置的时候选择USB接口即可，芯片的具体型号可以根据用户自己的需求来选择，通信接口可以选择JTAG接口或者SWD接口，调试的模式选择HSS模式，并在elf file对话框中加载可执行文件。

勾选需要显示的变量名。

然后直接按F5开始运行，针对不同用户的使用情况，J-Scope可能会弹出不同的提示对话框，直接点击OK确认即可。

J-Scope上位机软件打印出波形。

RTT模式获取数据

RTT模式获取数据的原理就是利用SWD接口完成数据从MCU到J-Scope上位机软件的数据传输。此模式相对于HSS模式有更高的数据传输速率，最高可以达到2MB/s，并且随时可以连接目标板且不影响目标板的正常功能，并且可以添加时间戳。

01、RTT模式使用方法

1.1 软件配置

在目标工程中加入RTT的代码文件，具体的操作请参考上一讲RTT的移植教程，在主函数中加入RTT的初始化配置。

SEGGER_RTT_ConfigUpBuffer(1,"JScope_u2",buf,2048,SEGGER_RTT_MODE_NO_BLOCK_SKIP);

然后创建一个定时器，利用定时器定时向J-Scope上位机发送数据。

/******************************************************************************
 * @brief
 * @param
 * @retval
 * @attention
******************************************************************************/
void TIM2_Configure(void)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    NVIC_InitTypeDef        NVIC_InitStructure;

    TIM_DeInit(TIM2);

    /* Enable TIM2 Clock */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

    /* Config TIM2 Every 1ms Generate Interrupt */
    TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
    TIM_TimeBaseStructure.TIM_Prescaler           = (RCC_GetSysClockFreq() / 1000 - 1);
    TIM_TimeBaseStructure.TIM_CounterMode       = TIM_CounterMode_Up;
    TIM_TimeBaseStructure.TIM_Period                = (1000 - 1);
    TIM_TimeBaseStructure.TIM_ClockDivision         = TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_RepetitionCounter     = 0;
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

    /* Clear TIM2 Update Flag */
    TIM_ClearFlag(TIM2, TIM_FLAG_Update);

    /* Enable TIM2 Update Interrupt */
    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);

    /* Enable TIM2 */
    TIM_Cmd(TIM2, ENABLE);

    /* Enable TIM2 Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}


/******************************************************************************
 * @brief
 * @param
 * @retval
 * @attention
******************************************************************************/
void TIM2_IRQHandler(void)
{

    /* Clear TIM2 Update Interrupt Flag */
    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    SEGGER_RTT_Write(1, &g_SineWave128[(i++) % 128], 2);
}

在主函数中初始化TIM2的配置：

TIM2_Configure();

1.2 J-Scope上位机配置

RTT模式的配置与HSS模式的配置类似，但是在J-Scope Configuration选项卡中的Sampling Source界面选择RTT模式，在RTT模式下不需要加载可执行文件。

配置完成以后运行可以看到J-Scope上位机打印的波形。

来源：灵动微电子
免责声明：本文为转载文章，转载此文目的在于传递更多信息，版权归原作者所有。本文所用视频、图片、文字如涉及作品版权问题，请联系小编进行处理（联系邮箱：cathy@eetrend.com）。