PyLink 是一个 Python 包，使您能够从 Python 控制 J-Link。该库是Square开发的，使我们能够利用 J-Link 作为测试基础设施的一部分，该基础设施是用 Python 编写的。

详细信息请参考：https://pylink.readthedocs.io/en/latest/

安装

$ pip 安装 pylink-square

外部依赖

为了使用该库， 需要 SEGGER 提供的J-Link 软件和开发包。获得开发包的副本后，您就可以开始使用 PyLink。

为您的JLINK控制创建类：

创建JLINK类，定义JLINK类属性

class jlink_control_class:
    def __init__(self, jlink_address):
        self.jlink_address = jlink_address
        self.jlink_dev = pylink.JLink()

1， 创建JLINK类的方法

# jlink_type 配置JLINK协议，选择‘JATG’或者‘SWD’

# jlink_pin_reset 配置JLINK复位脚状态

def jlink_connect(self,jlink_type='JTAG',jlink_pin_reset=1):

2， 优化PyLink原生寄存器读写函数

以Goodix 32位BLE MCU为例讲解优化PyLink原生寄存器读写函数。

def memory_read32(self, addr, num_words, zone=None):
        """Reads memory from the target system in units of 32-bits.          
Args:
          self (JLink): the ``JLink`` instance
          addr (int): start address to read from
          num_words (int): number of words to read

PyLink自带的32位寄存器读写函数只能读写完整的32位寄存器信息，若需要读或者写该寄存器某几个bit信息，可以重构该函数。

# bitField传入需要读写的某几位bit参数

def memWriteBit(self,address, bitField = [], bit_value = None):
def memReadBit(self, address, bitField = []):

比如：写入0xA000C510地址第19到23bit域的值0x1F，然后读取第19到23bit信息

memWriteBit(0xA000C510,bitField = [19,23],bit_value = 0x1F)
memReadBit(0xA000C510,bitField = [19,23])

完整JLINK类定义代码参考如下：

class jlink_control_class:
    def __init__(self, jlink_address):
       self.jlink_address = jlink_address
       self.jlink_dev = pylink.JLink()  
       
	def jlink_connect(self,jlink_type='JTAG',jlink_pin_reset=1):
		# self.jlink_dev = pylink.JLink()
		self.jlink_dev.open(serial_no=self.jlink_address)#open jlink commander find the Jlink S/N 483126086
		print(self.jlink_dev.product_name)
		if self.jlink_dev.opened()==True:
			print('jlink control board connect success!!!')
		else:
			print('jlink control board connect fail!!!')

		if jlink_type=='JTAG':
			self.jlink_dev.set_tif(pylink.enums.JLinkInterfaces.JTAG)
		elif jlink_type=='SWD':
			self.jlink_dev.set_tif(pylink.enums.JLinkInterfaces.SWD)
		else:
			print('Please specify target interface (JTAG or SWD) !!!')
			sys.exit()

		if jlink_pin_reset==1:
			self.jlink_dev.set_reset_pin_low()
			time.sleep(1)
			self.jlink_dev.set_reset_pin_high()
			print('jlink reset pin control success!!!')
		self.jlink_dev.connect('Cortex-M4')
		if self.jlink_dev.target_connected()==True:
			print('jlink target connect success!!!')
		else:
			print('jlink target connect fail!!!')
			
	def memWriteBit(self,address, bitField = [], bit_value = None):
		print("\n\033[1;34;40m >>> \033[0m memWriteBit")
		print('address=')
		print(hex(address), '.', str(bitField[0]), ':', str(bitField[1]))
		valuelist=['']
		dataU32=['']
		valuelist[0] = bit_value
		print('bit_value=')
		print(hex(valuelist[0]))
		bitlen = bitField[1] - bitField[0] + 1
		if len(bin(bit_value)) - 2 > bitlen:
			print()
			print("   !!!!!!!!!!!!!!!!!!!!!!!!!!!!")
			print("      \033[1;37;41mERROR:")
			print('The value written exceeds the maximum bit_value\n')
			sys.exit()
			return -1
		tempvalue = self.jlink_dev.memory_read32(address,1)
		y = 0
		for x in range(1,bitlen+1):
			y = y + 2 ** (x-1)
			pass
		y = y << bitField[0]		
		y = y ^ 0xffffffff
		valuelist[0] = (y & tempvalue[0]) | (bit_value<<bitField[0])
		dataU32[0] = int(hex(valuelist[0]),16)
		print('whole=', hex(dataU32[0]))
		self.jlink_dev.memory_write32(address,dataU32)		
		return 0		
		
	def memReadBit(self, address, bitField = []):
		list=[]
		numWords = 1
		print("\n\033[1;36;40m >>> \033[0m memReadBit")
		print('address=')
		xo = self.jlink_dev.memory_read32(address,numWords)
		dataU32 = hex(xo[0])
		dataU32=dataU32.rstrip('L')
		list.append(int(dataU32,16))
		list.append(0)
		bitlen = bitField[1] - bitField[0] + 1
		temp = xo[0] >> bitField[0]
		y = 0
		for x in range(1,bitlen+1):
			y = y + 2 ** (x-1)
			pass
		# print(y)
		y = y & temp
		print(hex(address), '.', str(bitField[0]), ':', str(bitField[1]), '=',hex(y))
		print('whole=', dataU32)
		return y