def write_zstring(self, reg, value, orders=0):
cv = ConvertValue()
cv.convert_zstring(value, orders)
cache = self.cache
slave_address = cache.slave_address
lh = cache.lh
lh.command(PresetMultipleRegisters(slave_address, reg, cv.buffer))
def write_time_6(self, reg, time_value, orders=0):
#tt = time.localtime(time_value)
##print 'write_time_6 ', tt
#self.write_word(reg, tt[5], orders)
#self.write_word(reg+1, tt[4], orders)
#self.write_word(reg+2, tt[3], orders)
#self.write_word(reg+3, tt[2], orders)
#self.write_word(reg+4, tt[1], orders)
#self.write_word(reg+5, tt[0], orders)
cv = ConvertValue()
cv.convert_time_6(time_value, orders)
cache = self.cache
slave_address = cache.slave_address
lh = cache.lh
lh.command(PresetMultipleRegisters(slave_address, reg, cv.buffer))
def perform_command(self, cmd):
_module_lock.acquire()
try:
try:
if (cmd.function == 1) or (cmd.function == 2): #read coil / input status
base_register = 1
if cmd.function == 2: base_register = 10001
if len(cmd.buffer) > 5:
register = cmd.register()
count = cmd.count()
answer = ConvertValue()
for i in range(register,register+count):
if self.debug: print '>>>> MODBUS Read coil offset: ' + str(i)
value = 0
if self.map.has_key(i+base_register):
for r in self.map[i+base_register]:
value |= int(r.read())
answer.convert_bits(value)
if self.debug: print 'server response: ', register, count, answer
response = ServerReadResponse(cmd.slave_address, cmd.function, None)
response.buffer += chr((count + 7) / 8)
response.buffer += answer.collapsed_buffer()
return response
elif (cmd.function == 3) or (cmd.function == 4): #read holding registers
base_register = 40001
if cmd.function == 4: base_register = 30001
if len(cmd.buffer) > 5:
register = cmd.register()
count = cmd.count()
answer = []
for i in range(register,register+count):
if self.debug: print '>>>> MODBUS Read offset: ' + str(i)
#combine the outputs of all nodes that contribute to this register
value = [0,0]
if self.map.has_key(i+base_register):
nodes = self.map[i+base_register]
force = len(nodes) > 1
for r in nodes:
val_list = r.read(i)
value[0] |= val_list[0]
value[1] |= val_list[1]
answer.extend(value)
if self.debug: print 'server response: ', register, count, answer
return ServerReadResponse(cmd.slave_address, cmd.function, answer)
elif cmd.function == 5: #force single coil
if len(cmd.buffer) > 5:
register = cmd.register()
value = cmd.word_at(4)
if value: value = 1
if self.map.has_key(register+1):
for r in self.map[register+1]:
r.write(value != 0)
else:
return ErrorResponse(cmd.slave_address, cmd.function, 2) #ILLEGAL DATA ADDRESS
return ServerWriteResponse(cmd)
elif cmd.function == 6: #write single register
if len(cmd.buffer) > 5:
register = cmd.register()
if self.map.has_key(register+40001):
nodes = self.map[register+40001]
force = len(nodes) > 1
for r in nodes:
#for r in self.map[register+40001]:
r.write(register, cmd.buffer[4:6])
if force: #if more than one node at this register, force update to value
r.convert_buffer_to_value()
r.buffer = None
else:
return ErrorResponse(cmd.slave_address, cmd.function, 2) #ILLEGAL DATA ADDRESS
return ServerWriteResponse(cmd)
elif cmd.function == 16: #write multiple registers
if len(cmd.buffer) > 6:
register = cmd.register()
if self.debug: print 'register', str(register)
count = cmd.count()
if self.debug: print 'count', str(count)
for i in range(0, count):
byte_offset = i*2 + 7
if self.debug: print '>>>> MODBUS write offset: ' + str(register+i)
if self.map.has_key(register+i+40001):
nodes = self.map[register+i+40001]
for r in nodes:
if self.debug:
print 'node', str(r), str(register+i), str(cmd)
print repr(cmd.buffer)
print str(byte_offset)
print repr(cmd.buffer[byte_offset:byte_offset+2])
print type(cmd.buffer[byte_offset:byte_offset+2])
#print repr(cmd.buffer[byte_offset:byte_offset+2].tostring())
#print repr(r.write)
print 'about to write'
r.write(register+i, cmd.buffer[byte_offset:byte_offset+2]) #.tostring())
if self.debug: print 'finished write'
else:
return ErrorResponse(cmd.slave_address, cmd.function, 2) #ILLEGAL DATA ADDRESS
if self.debug: print 'server response: ', register, count #, answer
return ServerWriteResponse(cmd)
elif cmd.function == 15: #write multiple coils
if len(cmd.buffer) > 6:
register = cmd.word_at(2)
count = cmd.word_at(4)
for i in range(0, count):
byte_offset = (i/8) + 7
bit_offset = i & 0x7
if self.debug: print '>>>> MODBUS write offset: ' + str(register+i)
if self.map.has_key(register+i+1):
value = ord(cmd.buffer[byte_offset]) & (1 << bit_offset)
for r in self.map[register+i+1]:
r.write(value != 0)
else:
return ErrorResponse(cmd.slave_address, cmd.function, 2) #ILLEGAL DATA ADDRESS
if self.debug: print 'server response: ', register, count, answer
return ServerWriteResponse(cmd)
if self.debug: print 'Modbus device: Error response sent', cmd.buffer
return ErrorResponse(cmd.slave_address, cmd.function + 128, 1)
except:
msglog.exception()
if self.debug: print 'modbus server exception during command'
return ErrorResponse(cmd.slave_address, cmd.function + 128, 4)
finally:
_module_lock.release()
def perform_command(self, cmd):
_module_lock.acquire()
try:
try:
if (cmd.function == 1) or (cmd.function
== 2): #read coil / input status
base_register = 1
if cmd.function == 2: base_register = 10001
if len(cmd.buffer) > 5:
register = cmd.register()
count = cmd.count()
answer = ConvertValue()
for i in range(register, register + count):
if self.debug:
print '>>>> MODBUS Read coil offset: ' + str(i)
value = 0
if self.map.has_key(i + base_register):
for r in self.map[i + base_register]:
value |= int(r.read())
answer.convert_bits(value)
if self.debug:
print 'server response: ', register, count, answer
response = ServerReadResponse(cmd.slave_address,
cmd.function, None)
response.buffer += chr((count + 7) / 8)
response.buffer += answer.collapsed_buffer()
return response
elif (cmd.function == 3) or (cmd.function
== 4): #read holding registers
base_register = 40001
if cmd.function == 4: base_register = 30001
if len(cmd.buffer) > 5:
register = cmd.register()
count = cmd.count()
answer = []
for i in range(register, register + count):
if self.debug:
print '>>>> MODBUS Read offset: ' + str(i)
#combine the outputs of all nodes that contribute to this register
value = [0, 0]
if self.map.has_key(i + base_register):
nodes = self.map[i + base_register]
force = len(nodes) > 1
for r in nodes:
val_list = r.read(i)
value[0] |= val_list[0]
value[1] |= val_list[1]
answer.extend(value)
if self.debug:
print 'server response: ', register, count, answer
return ServerReadResponse(cmd.slave_address,
cmd.function, answer)
elif cmd.function == 5: #force single coil
if len(cmd.buffer) > 5:
register = cmd.register()
value = cmd.word_at(4)
if value: value = 1
if self.map.has_key(register + 1):
for r in self.map[register + 1]:
r.write(value != 0)
else:
return ErrorResponse(cmd.slave_address,
cmd.function,
2) #ILLEGAL DATA ADDRESS
return ServerWriteResponse(cmd)
elif cmd.function == 6: #write single register
if len(cmd.buffer) > 5:
register = cmd.register()
if self.map.has_key(register + 40001):
nodes = self.map[register + 40001]
force = len(nodes) > 1
for r in nodes:
#for r in self.map[register+40001]:
r.write(register, cmd.buffer[4:6])
if force: #if more than one node at this register, force update to value
r.convert_buffer_to_value()
r.buffer = None
else:
return ErrorResponse(cmd.slave_address,
cmd.function,
2) #ILLEGAL DATA ADDRESS
return ServerWriteResponse(cmd)
elif cmd.function == 16: #write multiple registers
if len(cmd.buffer) > 6:
register = cmd.register()
if self.debug: print 'register', str(register)
count = cmd.count()
if self.debug: print 'count', str(count)
for i in range(0, count):
byte_offset = i * 2 + 7
if self.debug:
print '>>>> MODBUS write offset: ' + str(
register + i)
if self.map.has_key(register + i + 40001):
nodes = self.map[register + i + 40001]
for r in nodes:
if self.debug:
print 'node', str(r), str(register +
i), str(cmd)
print repr(cmd.buffer)
print str(byte_offset)
print repr(
cmd.
buffer[byte_offset:byte_offset +
2])
print type(
cmd.
buffer[byte_offset:byte_offset +
2])
#print repr(cmd.buffer[byte_offset:byte_offset+2].tostring())
#print repr(r.write)
print 'about to write'
r.write(
register + i,
cmd.buffer[byte_offset:byte_offset +
2]) #.tostring())
if self.debug: print 'finished write'
else:
return ErrorResponse(cmd.slave_address,
cmd.function,
2) #ILLEGAL DATA ADDRESS
if self.debug:
print 'server response: ', register, count #, answer
return ServerWriteResponse(cmd)
elif cmd.function == 15: #write multiple coils
if len(cmd.buffer) > 6:
register = cmd.word_at(2)
count = cmd.word_at(4)
for i in range(0, count):
byte_offset = (i / 8) + 7
bit_offset = i & 0x7
if self.debug:
print '>>>> MODBUS write offset: ' + str(
register + i)
if self.map.has_key(register + i + 1):
value = ord(cmd.buffer[byte_offset]) & (
1 << bit_offset)
for r in self.map[register + i + 1]:
r.write(value != 0)
else:
return ErrorResponse(cmd.slave_address,
cmd.function,
2) #ILLEGAL DATA ADDRESS
if self.debug:
print 'server response: ', register, count, answer
return ServerWriteResponse(cmd)
if self.debug:
print 'Modbus device: Error response sent', cmd.buffer
return ErrorResponse(cmd.slave_address, cmd.function + 128, 1)
except:
msglog.exception()
if self.debug: print 'modbus server exception during command'
return ErrorResponse(cmd.slave_address, cmd.function + 128, 4)
finally:
_module_lock.release()
