Modbus communication in these applications using serial communication / RS232 and Modbus RTU.
This application use simple modbus with Python programming on Raspberry Pi, and not use modbus from a third party.
For the hardware used in this application:
1. PLC
2. Raspberry Pi (Only for setting, using: monitor, keyboard, mouse, adapter, flash disk)
3. Serial PLC Cable
4.Serial Module ,and
5. Serial Crossover Connector.
For the connection beetween PLC and Raspberry Pi, Raspberry Pi Setting
(Auto Login, Install PySerial, Setup UART Pins, Auto Run Python after
Booting) :
Connection of Modbus RTU Communication Between PLC and Raspberry Pi:
About Modbus:
Modbus application using function code 03, and function code 16. for this function code, you can go to the link:
http://program-plc.blogspot.com/2014/09/how-to-make-simple-modbus-rtu.html
Python Code of Modbus Communication on Raspberry Pi:
import serial
import random
#Sub Program
#CRC
Calculation
def CRCcal(msg):
#CRC (Cyclical Redundancy Check)
Calculation
CRC = 0xFFFF
CRCHi = 0xFF
CRCLo = 0xFF
CRCLSB = 0x00
for i in range(0,
len(msg)-2,+1):
CRC = (CRC ^ msg[i])
for j in range(0,
8):
CRCLSB = (CRC & 0x0001);
CRC = ((CRC >> 1) &
0x7FFF)
if (CRCLSB == 1):
CRC = (CRC ^ 0xA001)
CRCHi = ((CRC >> 8) & 0xFF)
CRCLo = (CRC & 0xFF)
return (CRCLo,CRCHi)
#CRC Valdation
def CRCvalid(resp):
CRC = CRCcal(resp)
if (CRC[0]==resp[len(resp)-2])
& (CRC[1]==resp[len(resp)-1]):return True
return False
#Modbus
Function Code 16 = Preset Multiple Registers
def Func16Modbus(slave,start,values):
Slave_Address = slave
Function = 16
Starting_Address = start
NumberofRegisters = len(values)
Byte_Count = NumberofRegisters * 2
message = [0 for i in range(9 + 2 * NumberofRegisters)]
#index0 = Slave
Address
message[0] = (Slave_Address & 0xFF)
#index1 = Function
message[1] = (Function & 0xFF)
#index2 = Starting Address Hi
message[2] = ((Starting_Address >> 8)
& 0xFF)
#index3 = Starting Address Lo
message[3] = (Starting_Address & 0xFF)
#index4 = Number of Registers Hi
message[4] = ((NumberofRegisters >>
8) & 0xFF)
#index5 = Number of Registers Lo
message[5] = (NumberofRegisters & 0xFF)
#index6 = Byte Count
message[6] = (Byte_Count & 0xFF)
for i in range(0,
NumberofRegisters):
#Data Hi, index7 and index9
message[7 + 2 * i] = ((values[i]
>> 8) & 0xFF)
#Data Lo, index8 and index10
message[8 + 2 * i] = values[i] &
0xFF
#CRC (Cyclical
Redundancy Check) Calculation
CRC = CRCcal(message)
#index11= CRC Lo
message[len(message)
- 2] = CRC[0]#CRCLo
#index12 = CRC Hi
message[len(message)
- 1] = CRC[1]#CRCHi
if ser.isOpen:
ser.write("".join(chr(h)
for
h in
message))
reading = ser.read(8)
response = [0 for i in range(len(reading))]
for i in range(0,
len(reading)):
response[i] = ord(reading[i])
if len(response)==8:
CRCok = CRCvalid(response)
if CRCok &
(response[0]==slave) & (response[1]==Function):return True
return False
#Modbus
Function Code 03 = Read Holding Registers
def Func03Modbus(slave,start,NumOfPoints):
#Function 3 request is always 8 bytes
message = [0 for i in range(8)]
Slave_Address = slave
Function = 3
Starting_Address = start
Number_of_Points = NumOfPoints
#index0 = Slave
Address
message[0] = Slave_Address
#index1 = Function
message[1] = Function
#index2 = Starting Address Hi
message[2] = ((Starting_Address >>
8)& 0xFF)
#index3 = Starting Address Lo
message[3] = (Starting_Address& 0xFF)
#index4 = Number of Points Hi
message[4] = ((Number_of_Points >>
8)& 0xFF)
#index5 = Number of Points Lo
message[5] = (Number_of_Points& 0xFF)
#CRC (Cyclical Redundancy Check)
Calculation
CRC = CRCcal(message)
#index6= CRC Lo
message[len(message)
- 2] = CRC[0]#CRCLo
#index7 = CRC Hi
message[len(message)
- 1] = CRC[1]#CRCHi
if ser.isOpen:
ser.write("".join(chr(h)
for
h in message))
responseFunc3total = 5 + 2 *
Number_of_Points
reading = ser.read(responseFunc3total)
response = [0 for i in range(len(reading))]
for i in range(0,
len(reading)):
response[i] = ord(reading[i])
if len(response)==responseFunc3total:
CRCok = CRCvalid(response)
if CRCok &
(response[0]==slave) & (response[1]==Function):
#Byte Count in index 3 =
responseFunc3[2]
#Number of Registers = byte
count / 2 = responseFunc3[2] / 2
registers = ((response[2] /
2)& 0xFF)
values = [0 for i in
range(registers)]
for i in range(0, len(values)):
#Data Hi and Registers1
from Index3
values[i] = response[2 * i
+ 3]
#Move to Hi
values[i] <<= 8
#Data Lo and Registers1
from Index4
values[i] += response[2 * i
+ 4]
negatif =
values[i]>>15
if
negatif==1:values[i]=values[i]*-1
return values
return ()
#Main Program
#Serial Port
9600,8,E,1
#Serial Open
try:
ser = serial.Serial(
port = '/dev/ttyAMA0',
baudrate = 9600,
bytesize = serial.EIGHTBITS,
parity = serial.PARITY_EVEN,
stopbits = serial.STOPBITS_ONE,
timeout = 0.2
)
except Exception, e:
raise ValueError(e)
print "START"
while 1:
#Serial Open Check
if not ser.isOpen:ser.open()
#Read of Registers
Func03ArrayValue = Func03Modbus(1,0,2);#slave,start,number of registers
if len(Func03ArrayValue)>0:
for i in range(0,
len(Func03ArrayValue)):
print "Read of Registers" + str(i) + " = " + str(Func03ArrayValue[i])
#Fill Random Value for Write
totalvalue=2
val = [0 for i in range(totalvalue)]
for i in range(0,
len(val)):
val[i] = random.randrange(-32767,32767)
#Random Valiue from -32767 to max 32767
#Write of Registers
WriteValid =
Func16Modbus(1,2,val)#slave,start,array value
if WriteValid:
for i in range(0,
len(val)):
print "Write of Registers" + str(i) + " = " + str(val[i])
print "#################################"
