屏蔽和修改来自 FPGA 串行通信的 8 字节信号
Mask and modify 8-byte signal from FPGA serial communication
我很难创建一个掩码来只写入我的数据的某些位。
目前我通过串口读取 32 位数据。阅读后我得到以下信息：
b'rt 00000000\n'
这有字节类型。我假设，我来自某个寄存器的 32 位被转换为 8 个字节。然而，这个寄存器有多个字段，比如说 field1 的范围从 bit 0 到 4，field2 的范围从 bit 4 到 5，field3 的范围从 bit 5 到 8 等等，所以它们在数量、长度和位置上有所不同，具体取决于寄存器。现在我想读取信息，在某个字段上应用掩码，修改该字段，然后将信息写回我的串行设备。我已经编写了额外的函数来获取字段数、字段偏移量和字段宽度的信息。
到目前为止我取得的成就：
read_value = read_register_byte(s, r, regName) #output: '00000000'
#from hex to int
read_value = int(read_value, 16)
#from int to 32bit-bin without prefix
read_value = format(read_value, '032b')
#define mask range
maskStart = len(read_value) - (offsets[fieldNo] + widths[fieldNo]) #for field0 this results in 28
maskStop = len(read_value) - offsets[fieldNo] #this results in 32
#create mask template (32bit)
mask = [0]*32
j = 0
#insert F for mask range
for i in read_value:
mask[j] = read_value[j]
if j >= maskStart and j < maskStop:
mask[j]='F'
j+=1
#to string
tempMask=""
for i in mask:
tempMask += i
mask = tempMask
read_value
Out[96]: '00000000000000000000000000000000'
mask
Out[97]: '0000000000000000000000000000FFFF'
我想做的是只允许修改那些标有 F 的位。我确信这是非常糟糕的做法，但是如果我只能实现以下步骤，它应该可以工作：使用 read_value 操作我的掩码，将我的数据转换回 8 字节格式并写入我的串行设备。
编辑：
Field = namedtuple("Field", ["pos_lsb", "width"])
REG_WIDTH = 32 #r.width
REG_HEX_DIGITS = REG_WIDTH // 4
def create_mask(pos_lsb, width):
mask = ((1 << width)-1) << pos_lsb
return mask
def get_field(reg_value, field):
mask = create_mask(*field)
field_value = (reg_value & mask) >> field.pos_lsb
return field_value
def set_field(reg_value, field, new_value):
mask = create_mask(*field)
reg_value = (reg_value & ~mask) | (new_value << field.pos_lsb)
return reg_value
def value_from_string(reg_value_string):
return int(reg_value_string, 16)
def value_to_string(reg_value):
return f"{reg_value:0{REG_HEX_DIGITS}X}"
def write_field(s, r, regName, fieldNo, data):
""" Writes to a single field of a Trixel register """
""" debug block """
# s = open_serial_port()
# r = Registermap()
# regName = 'tcm_control'
# fieldNo = 0 #1st field
# data = 5
""" end of debug block """
regAddress = r.get_register_address(regName)
fields = r.get_register(regName, 'fields')
offsets = r.get_register(regName, 'offsets')
widths = r.get_register(regName, 'widths')
if fieldNo+1 > fields:
print('fieldNo out of range (max fields: ' + str(fields) + '). Aborting..')
return 0
fieldStart = r.baseAddress + regAddress + offsets[fieldNo]
addr = r.baseAddress + regAddress
register_value_string = read_register_byte(s, r, regName)
field = Field(pos_lsb=offsets[fieldNo], width=widths[fieldNo])
new_field_value = data
# Update field
print("Register: " + str(regName) + ", fieldNo: " + str(fieldNo+1) + "(" + str(fieldNo) + ")" + ", offset (hex): " + hex(fieldStart))
print("Fieldname: " + str(r.get_register(regName,'descriptions')[fieldNo]))
print(f"Original register value: {register_value_string}")
reg_val = value_from_string(register_value_string)
field_value = get_field(reg_val, field)
print(f"Original field value: {field_value} (0x{field_value:x} in hex)")
print(f"Setting field to {new_field_value} (0x{new_field_value:x} in hex)")
reg_val = set_field(reg_val, field, new_field_value)
field_value = get_field(reg_val, field)
print(f"New field value: {field_value} (0x{field_value:x} in hex)")
new_reg_val_string = value_to_string(reg_val)
print(f"New register value to write to FPGA: {new_reg_val_string}")
#write to FPGA
cmd = ("mwr {:08X}".format(addr) + " " + new_reg_val_string + " \n").encode()
message = s.write(cmd)
if message != len(cmd):
print('Error in Write! Bytes expected: ' + str(len(cmd)) + ', written: ' + str(message) + ', cmd: ' + str(cmd))
elif message == len(cmd):
print('Write to register ' + str(hex(addr)) + ' OK.')
工作示例：
write_field(s, r, 'tcm_control', 3, 1)
Register: tcm_control, fieldNo: 4(3), offset (hex): 0x50000406
Fieldname: Should be released after configuring all TCM registers over AXI
Original register value: 00000071
Original field value: 1 (0x1 in hex)
Setting field to 1 (0x1 in hex)
New field value: 1 (0x1 in hex)
New register value to write to FPGA: 00000071
Write to register 0x50000400 OK.
失败示例：
write_field(s, r, 'tcm_control', 3, 2)
Register: tcm_control, fieldNo: 4(3), offset (hex): 0x50000406
Fieldname: Should be released after configuring all TCM registers over AXI
Original register value: 00000071
Original field value: 1 (0x1 in hex)
Setting field to 2 (0x2 in hex)
New field value: 0 (0x0 in hex)
New register value to write to FPGA: 000000B1
Write to register 0x50000400 OK.
read_register_byte(s, r, 'tcm_control')
Out[15]: '00000031'
我认为您的处理方式有误。请查看这段（评论不多的）代码，看看这是否是您真正想要的：
from collections import namedtuple
REG_WIDTH = 32
REG_HEX_DIGITS = REG_WIDTH // 4
Field = namedtuple("Field", ["pos_lsb", "width"])
def create_mask(pos_lsb, width):
mask = ((1 << width)-1) << pos_lsb
return mask
def get_field(reg_value, field):
mask = create_mask(*field)
field_value = (reg_value & mask) >> field.pos_lsb
return field_value
def set_field(reg_value, field, new_value):
mask = create_mask(*field)
reg_value = (reg_value & ~mask) | (new_value << field.pos_lsb)
return reg_value
def value_from_string(reg_value_string):
return int(reg_value_string, 16)
def value_to_string(reg_value):
return f"{reg_value:0{REG_HEX_DIGITS}X}"
register_value_string = "0F00F0FF"
field1 = Field(pos_lsb=3, width=5)
new_field_value = 0x12
# Update field1.
print(f"Original register value: {register_value_string}")
reg_val = value_from_string(register_value_string)
field_value = get_field(reg_val, field1)
print(f"Original field value: {field_value} (0x{field_value:x} in hex)")
print(f"Setting field to {new_field_value} (0x{new_field_value:x} in hex)")
reg_val = set_field(reg_val, field1, new_field_value)
field_value = get_field(reg_val, field1)
print(f"New field value: {field_value} (0x{field_value:x} in hex)")
new_reg_val_string = value_to_string(reg_val)
print(f"New register value to write to FPGA: {new_reg_val_string}")
输出：
Original register value: 0F00F0FF
Original field value: 31 (0x1f in hex)
Setting field to 18 (0x12 in hex)
New field value: 18 (0x12 in hex)
New register value to write to FPGA: 0F00F097
我相信这更符合您的要求。如果你想让我进一步解释，请告诉我。
我很难创建一个掩码来只写入我的数据的某些位。 目前我通过串口读取 32 位数据。阅读后我得到以下信息：
b'rt 00000000\n'
这有字节类型。我假设，我来自某个寄存器的 32 位被转换为 8 个字节。然而，这个寄存器有多个字段，比如说 field1 的范围从 bit 0 到 4，field2 的范围从 bit 4 到 5，field3 的范围从 bit 5 到 8 等等，所以它们在数量、长度和位置上有所不同，具体取决于寄存器。现在我想读取信息，在某个字段上应用掩码，修改该字段，然后将信息写回我的串行设备。我已经编写了额外的函数来获取字段数、字段偏移量和字段宽度的信息。 到目前为止我取得的成就：
read_value = read_register_byte(s, r, regName) #output: '00000000'
#from hex to int
read_value = int(read_value, 16)
#from int to 32bit-bin without prefix
read_value = format(read_value, '032b')
#define mask range
maskStart = len(read_value) - (offsets[fieldNo] + widths[fieldNo]) #for field0 this results in 28
maskStop = len(read_value) - offsets[fieldNo] #this results in 32
#create mask template (32bit)
mask = [0]*32
j = 0
#insert F for mask range
for i in read_value:
mask[j] = read_value[j]
if j >= maskStart and j < maskStop:
mask[j]='F'
j+=1
#to string
tempMask=""
for i in mask:
tempMask += i
mask = tempMask
read_value
Out[96]: '00000000000000000000000000000000'
mask
Out[97]: '0000000000000000000000000000FFFF'
我想做的是只允许修改那些标有 F 的位。我确信这是非常糟糕的做法，但是如果我只能实现以下步骤，它应该可以工作：使用 read_value 操作我的掩码，将我的数据转换回 8 字节格式并写入我的串行设备。
编辑：
Field = namedtuple("Field", ["pos_lsb", "width"])
REG_WIDTH = 32 #r.width
REG_HEX_DIGITS = REG_WIDTH // 4
def create_mask(pos_lsb, width):
mask = ((1 << width)-1) << pos_lsb
return mask
def get_field(reg_value, field):
mask = create_mask(*field)
field_value = (reg_value & mask) >> field.pos_lsb
return field_value
def set_field(reg_value, field, new_value):
mask = create_mask(*field)
reg_value = (reg_value & ~mask) | (new_value << field.pos_lsb)
return reg_value
def value_from_string(reg_value_string):
return int(reg_value_string, 16)
def value_to_string(reg_value):
return f"{reg_value:0{REG_HEX_DIGITS}X}"
def write_field(s, r, regName, fieldNo, data):
""" Writes to a single field of a Trixel register """
""" debug block """
# s = open_serial_port()
# r = Registermap()
# regName = 'tcm_control'
# fieldNo = 0 #1st field
# data = 5
""" end of debug block """
regAddress = r.get_register_address(regName)
fields = r.get_register(regName, 'fields')
offsets = r.get_register(regName, 'offsets')
widths = r.get_register(regName, 'widths')
if fieldNo+1 > fields:
print('fieldNo out of range (max fields: ' + str(fields) + '). Aborting..')
return 0
fieldStart = r.baseAddress + regAddress + offsets[fieldNo]
addr = r.baseAddress + regAddress
register_value_string = read_register_byte(s, r, regName)
field = Field(pos_lsb=offsets[fieldNo], width=widths[fieldNo])
new_field_value = data
# Update field
print("Register: " + str(regName) + ", fieldNo: " + str(fieldNo+1) + "(" + str(fieldNo) + ")" + ", offset (hex): " + hex(fieldStart))
print("Fieldname: " + str(r.get_register(regName,'descriptions')[fieldNo]))
print(f"Original register value: {register_value_string}")
reg_val = value_from_string(register_value_string)
field_value = get_field(reg_val, field)
print(f"Original field value: {field_value} (0x{field_value:x} in hex)")
print(f"Setting field to {new_field_value} (0x{new_field_value:x} in hex)")
reg_val = set_field(reg_val, field, new_field_value)
field_value = get_field(reg_val, field)
print(f"New field value: {field_value} (0x{field_value:x} in hex)")
new_reg_val_string = value_to_string(reg_val)
print(f"New register value to write to FPGA: {new_reg_val_string}")
#write to FPGA
cmd = ("mwr {:08X}".format(addr) + " " + new_reg_val_string + " \n").encode()
message = s.write(cmd)
if message != len(cmd):
print('Error in Write! Bytes expected: ' + str(len(cmd)) + ', written: ' + str(message) + ', cmd: ' + str(cmd))
elif message == len(cmd):
print('Write to register ' + str(hex(addr)) + ' OK.')
工作示例：
write_field(s, r, 'tcm_control', 3, 1)
Register: tcm_control, fieldNo: 4(3), offset (hex): 0x50000406
Fieldname: Should be released after configuring all TCM registers over AXI
Original register value: 00000071
Original field value: 1 (0x1 in hex)
Setting field to 1 (0x1 in hex)
New field value: 1 (0x1 in hex)
New register value to write to FPGA: 00000071
Write to register 0x50000400 OK.
失败示例：
write_field(s, r, 'tcm_control', 3, 2)
Register: tcm_control, fieldNo: 4(3), offset (hex): 0x50000406
Fieldname: Should be released after configuring all TCM registers over AXI
Original register value: 00000071
Original field value: 1 (0x1 in hex)
Setting field to 2 (0x2 in hex)
New field value: 0 (0x0 in hex)
New register value to write to FPGA: 000000B1
Write to register 0x50000400 OK.
read_register_byte(s, r, 'tcm_control')
Out[15]: '00000031'
我认为您的处理方式有误。请查看这段（评论不多的）代码，看看这是否是您真正想要的：
from collections import namedtuple
REG_WIDTH = 32
REG_HEX_DIGITS = REG_WIDTH // 4
Field = namedtuple("Field", ["pos_lsb", "width"])
def create_mask(pos_lsb, width):
mask = ((1 << width)-1) << pos_lsb
return mask
def get_field(reg_value, field):
mask = create_mask(*field)
field_value = (reg_value & mask) >> field.pos_lsb
return field_value
def set_field(reg_value, field, new_value):
mask = create_mask(*field)
reg_value = (reg_value & ~mask) | (new_value << field.pos_lsb)
return reg_value
def value_from_string(reg_value_string):
return int(reg_value_string, 16)
def value_to_string(reg_value):
return f"{reg_value:0{REG_HEX_DIGITS}X}"
register_value_string = "0F00F0FF"
field1 = Field(pos_lsb=3, width=5)
new_field_value = 0x12
# Update field1.
print(f"Original register value: {register_value_string}")
reg_val = value_from_string(register_value_string)
field_value = get_field(reg_val, field1)
print(f"Original field value: {field_value} (0x{field_value:x} in hex)")
print(f"Setting field to {new_field_value} (0x{new_field_value:x} in hex)")
reg_val = set_field(reg_val, field1, new_field_value)
field_value = get_field(reg_val, field1)
print(f"New field value: {field_value} (0x{field_value:x} in hex)")
new_reg_val_string = value_to_string(reg_val)
print(f"New register value to write to FPGA: {new_reg_val_string}")
输出：
Original register value: 0F00F0FF
Original field value: 31 (0x1f in hex)
Setting field to 18 (0x12 in hex)
New field value: 18 (0x12 in hex)
New register value to write to FPGA: 0F00F097
我相信这更符合您的要求。如果你想让我进一步解释，请告诉我。