【Trace32】使用Python调用cmm脚本，实现劳特巴赫Trace32的自动化操作

文章目录

• 1. cmm脚本命令
• • 1.1 重启单板
  • 1.2 文件操作
  • 1.3 打印、观测和设置变量
  • 1.4 程序运行
  • 1.5 断点
  • 1.6 延时等待
  • 1.7 加载源代码
• 2. 使用python调用cmm
• • 2.1 使用python执行单条cmm命令
  • 2.2 使用python执行cmm脚本
• 3. 案例
• • 3.1 获取函数的返回值
  • 3.2 获取函数内部变量的值

1. cmm脚本命令

cmm脚本自动化操作Trace32的常用命令如下：

注：
1.cmm脚本命令不区分大小写
2.;分号为cmm脚本的注释

1.1 重启单板

SYStem.RESetTarget 
r.s pc _start

注：SYStem.RESetTarget 相当于执行了可视化界面中的 In Target Reset

1.2 文件操作

; 打开 result.txt 文件，如果文件不存在就创建
OPEN #1 D:\result.txt /CREATE; 关闭 result.txt 文件
CLOSE #1

注：#1就是文件指针，相当于 f=open("result.txt","wb") 中的 f

1.3 打印、观测和设置变量

1.打印变量

; 将 result.txt 设置为用于打印变量的文件
Printer.File D:\result.txt; 表示把 g_result 变量打印到文件中（打印单个变量），此时会打印到 D:\result.txt 文件中
winprint.var.watch g_result ; 表示把 g_result1 和 g_result2 变量打印到文件中（打印多个变量）
winprint.var.watch g_result1 g_result2 

2.观测变量

; 在watch窗口显示 g_result 变量的值（观测单个变量）
Var.Watch g_result; 在watch窗口显示 g_result1 和 g_result2 变量的值（观测多个变量）
Var.Watch g_result1 g_result2 

3.设置变量值

; 设置变量 g_result 的值为1
V %e g_result = 1

1.4 程序运行

1.运行和结束程序

; 运行程序
Go；停止运行程序
Break

2.运行程序，并走到函数内部停下（断住）

; 运行程序，走到 max 函数首行停下
Go.direct max; 运行程序，走到 max 函数内部停下
Go.direct max+0x08

注：
1.max+0x08，其中的0x08为相对于max函数首行的偏移量
2.想要知道函数内部某行的断点地址是多少，可以先手动断点跑，断住以后观测劳特巴赫左下角就能知道断点地址

1.5 断点

1.打断点

; 在 max 函数首行打断点
Break.Set max; 在 max 函数内部打断点
Break.Set max+0x08

2.取消断点

; 清除所有断点
Break.Reset; 清除某个断点
Break.Reset 断点地址

1.6 延时等待

; 延时等待1秒
wait 1.s ; 等待上一条命令执行结束
Wait !run()

注：Go.direct 等命令，需要配合Wait !run()命令使用，否则脚本运行的时候可能会报错，因为程序运行到某个函数还需要时间，如果还没运行到此处，就执行下一条命令，可能会报错。

例：以下命令表示，运行到max函数，然后返回函数的值

Go.direct max
Wait !run()
Go.Return

解析：如果说，此时还未走到 max 函数中，就执行了Go.Return语句，那么此时没有值可以返回，就会报错，因此此处需要加上 Wait !run()

1.7 加载源代码

; 加载Code文件夹下的源代码
y.spath.SetRecurseDir  D:\Code

注：test.cmm 脚本是用例烧录 elf 的 cmm 脚本

2. 使用python调用cmm

t32rem.exe 可以用于执行cmm命令，根据Trace32的默认安装路径可知，t32rem.exe 的默认路径为 C:\T32\bin\Windows64\t32rem.exe

t32rem.exe既可用于执行单行cmm命令，也可以用于执行cmm脚本。

2.1 使用python执行单条cmm命令

语法如下：

t32rem.exe localhost port=20000 cmm命令

使用python执行cmm命令：以重启单板为例

import os# 重启单板并运行
cmd1 = "C:/T32/bin/Windows64/t32rem.exe localhost port=20000 SYStem.RESetTarget"
cmd2 = "C:/T32/bin/Windows64/t32rem.exe localhost port=20000 r.s pc _start"
cmd3 = "C:/T32/bin/Windows64/t32rem.exe localhost port=20000 Go"
os.system(cmd1)
os.system(cmd2)
os.system(cmd3)

2.2 使用python执行cmm脚本

语法如下：

t32rem.exe localhost port=20000 do cmm脚本

注：localhost表示本机，port=20000为Trace32的默认端口号

1.使用python执行cmm脚本：重启单板

新建文件 restart.cmm，内容如下：

SYStem.RESetTarget
r.s pc _start
Go

在同级目录下，再新建一个test.py，内容如下：

import os# 重启单板并运行
cmd = "C:/T32/bin/Windows64/t32rem.exe localhost port=20000 do restart.cmm"
os.system(cmd)

2.使用python执行cmm脚本：烧录elf文件

注：test.cmm 为用于烧录的cmm脚本

import os# 执行 test.cmm 脚本来烧录 test.elf 文件
cmd = "c:/T32/bin/windows64/t32rem.exe localhost port=20000 do test.cmm test.elf"
os.system(cmd)

3. 案例

3.1 获取函数的返回值

1.准备C代码内容如下：此处观测函数的返回值，也就是观测 g_result 变量的值。

#include int g_result; // 定义全局变量，方便观测int max(int num1, int num2) {if (num1 > num2) {g_result = num1;} else {g_result = num2;}   return g_result; 
}int main () {int ret;ret = max(100, 200);printf( "Max value is : %d\n", ret );return 0;
} 

注：
1.该代码用于编译生成max.elf文件，然后烧录至劳特巴赫中。
2.函数的局部变量只能走到函数内部才能观测，因此此处定义g_result为全局变量，是为了方便在程序任意位置都能观测。

2.新建一个 max.cmm 脚本，内容如下：

;创建result.txt，并将它设置为用于打印变量的文件
OPEN #1 D:\result.txt /CREATE
CLOSE #1
PRinTer.FILE D:\result.txt;重启单板
SYStem.RESetTarget 
r.s pc _start;运行到max函数，然后返回函数的值
Go.direct max
Wait !run()
Go.Return;把g_result变量打印到result.txt中
winprint.var.watch g_result

3.在 max.cmm 同级目录下 ，新建一个 test_max.py 脚本，内容如下：

import os
import timet32rem = "c:/T32/bin/windows64/t32rem.exe"
elf_file = "max.elf"
tc397_cmm = "tc397.cmm" # tc397.cmm为烧录elf文件用的cmm脚本
max_cmm = "max.cmm"
expected_result = 200 # 预期结果# 烧录max.elf文件
burn_cmd = f'{t32rem} localhost port=20000 do {tc397_cmm} {elf_file}' 
print(burn_cmd)
os.system(burn_cmd)# 执行max.cmm脚本，运行max.elf程序
run_cmd = f'{t32rem} localhost port=20000 do {max_cmm}'
print(run_cmd)
os.system(run_cmd)# 等待Trace32把程序跑完，并打印变量到D:/result.txt之后，再执行后续代码
time.sleep(5) # 获取实际结果，也就是跑出来的g_result变量的值
with open('D:/result.txt','r') as f:actual_result =  f.read()print(actual_result)# 对比实际结果与预期结果是否一致
if (expected_result == int(actual_result)):print("Success")
else:print("Failed")

3.2 获取函数内部变量的值

1.准备C代码内容如下：此处观测函数内部变量 num1 和 num2 的值

注：该代码用于编译生成max.elf文件，然后烧录至劳特巴赫中。

#include int max(int num1, int num2) {int result;if (num1 > num2) {result = num1;} else {result = num2;}   return result; 
}int main () {int ret;ret = max(100, 200);printf( "Max value is : %d\n", ret );return 0;
}

准备工作：首先烧录该 max.elf 文件，然后在 if (num1 > num2) 该行处，手动打个断点然后运行，此时程序会断住，然后观测劳特巴赫左下角的断点地址，该地址后续要用于cmm脚本设置断点时使用，假设得到该断点的地址为max+0x02。

2.新建一个 max.cmm 脚本，内容如下：

;创建result.txt，并将它设置为用于打印变量的文件
OPEN #1 D:\result.txt /CREATE
CLOSE #1
PRinTer.FILE D:\result.txt;重启单板
SYStem.RESetTarget 
r.s pc _start;先清除所有断点，然后再设置单个断点
Break.Reset
Break.Set max+0x02;运行程序，并等待运行到断点处
Go
Wait !run();把num1和num2变量打印到result.txt中
winprint.var.watch num1 num2

注：Break.Set max+0x02 和 Go，这两个命令也可以改为用 Go.direct max+0x02一条命令替代，效果是一样的。

3.在 max.cmm 同级目录下 ，新建一个 test_max.py 脚本，内容如下：

import os
import timet32rem = "c:/T32/bin/windows64/t32rem.exe"
elf_file = "max.elf"
tc397_cmm = "tc397.cmm" # tc397.cmm为烧录elf文件用的cmm脚本
max_cmm = "max.cmm"
expected_result = [100, 200] # 预期结果
actual_result = [] # 实际结果# 烧录max.elf文件
burn_cmd = f'{t32rem} localhost port=20000 do {tc397_cmm} {elf_file}' 
print(burn_cmd)
# os.system(burn_cmd)# 执行max.cmm脚本，运行max.elf程序
run_cmd = f'{t32rem} localhost port=20000 do {max_cmm}'
print(run_cmd)
# os.system(run_cmd)# 等待Trace32把程序跑完，并打印变量到D:/result.txt之后，再执行后续代码
time.sleep(5) # 获取实际结果，也就是跑出来的g_result变量的值
with open('D:/result.txt','r') as f:lines =  f.readlines()for line in lines:actual_result.append(int(line.strip()))print(actual_result)# 对比实际结果与预期结果是否一致
if (expected_result == actual_result):print("Success")
else:print("Failed")

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！