0.2
This commit is contained in:
John Long
@@ -0,0 +1,178 @@
|
||||
<?php
|
||||
/**
|
||||
* Phpmodbus Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
*
|
||||
* This source file is subject to the "PhpModbus license" that is bundled
|
||||
* with this package in the file license.txt.
|
||||
*
|
||||
* @author Jan Krakora
|
||||
* @copyright Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
* @license PhpModbus license
|
||||
* @category Phpmodbus
|
||||
* @package Phpmodbus
|
||||
* @version $id$
|
||||
*/
|
||||
|
||||
/**
|
||||
* IecType
|
||||
*
|
||||
* The class includes set of IEC-1131 data type functions that converts a PHP
|
||||
* data types to a IEC data type.
|
||||
*
|
||||
* @author Jan Krakora
|
||||
* @copyright Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
* @package Phpmodbus
|
||||
*/
|
||||
class IecType {
|
||||
|
||||
/**
|
||||
* iecBYTE
|
||||
*
|
||||
* Converts a value to IEC-1131 BYTE data type
|
||||
*
|
||||
* @param value value from 0 to 255
|
||||
* @return value IEC BYTE data type
|
||||
*
|
||||
*/
|
||||
function iecBYTE($value){
|
||||
return chr($value & 0xFF);
|
||||
}
|
||||
|
||||
/**
|
||||
* iecINT
|
||||
*
|
||||
* Converts a value to IEC-1131 INT data type
|
||||
*
|
||||
* @param value value to be converted
|
||||
* @return value IEC-1131 INT data type
|
||||
*
|
||||
*/
|
||||
function iecINT($value){
|
||||
return self::iecBYTE(($value >> 8) & 0x00FF) .
|
||||
self::iecBYTE(($value & 0x00FF));
|
||||
}
|
||||
|
||||
/**
|
||||
* iecDINT
|
||||
*
|
||||
* Converts a value to IEC-1131 DINT data type
|
||||
*
|
||||
* @param value value to be converted
|
||||
* @param value endianness defines endian codding (little endian == 0, big endian == 1)
|
||||
* @return value IEC-1131 INT data type
|
||||
*
|
||||
*/
|
||||
function iecDINT($value, $endianness = 0){
|
||||
// result with right endianness
|
||||
return self::endianness($value, $endianness);
|
||||
}
|
||||
|
||||
/**
|
||||
* iecREAL
|
||||
*
|
||||
* Converts a value to IEC-1131 REAL data type. The function uses function @use float2iecReal.
|
||||
*
|
||||
* @param value value to be converted
|
||||
* @param value endianness defines endian codding (little endian == 0, big endian == 1)
|
||||
* @return value IEC-1131 REAL data type
|
||||
*/
|
||||
function iecREAL($value, $endianness = 0){
|
||||
// iecREAL representation
|
||||
$real = self::float2iecReal($value);
|
||||
// result with right endianness
|
||||
return self::endianness($real, $endianness);
|
||||
}
|
||||
|
||||
/**
|
||||
* float2iecReal
|
||||
*
|
||||
* This function converts float value to IEC-1131 REAL single precision form.
|
||||
*
|
||||
* For more see [{@link http://en.wikipedia.org/wiki/Single_precision Single precision on Wiki}] or
|
||||
* [{@link http://de.php.net/manual/en/function.base-convert.php PHP base_convert function commentary}, Todd Stokes @ Georgia Tech 21-Nov-2007]*
|
||||
*
|
||||
* @param float value to be converted
|
||||
* @return value IEC REAL data type
|
||||
*/
|
||||
private function float2iecReal($value){
|
||||
$bias = 128;
|
||||
$cnst = 281; // 1 (carry bit) + 127 + 1 + 126 + 24 + 2 (round bits)
|
||||
$two_power_x = array(1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048,
|
||||
4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576,
|
||||
2097152, 4194304);
|
||||
//convert and seperate input to integer and decimal parts
|
||||
$val = abs($value);
|
||||
$intpart = floor($val);
|
||||
$decpart = $val - $intpart;
|
||||
//convert integer part
|
||||
for ($i=0;$i<$cnst;$i++) $real_significand_bin[$i] = 0;
|
||||
$i = $bias;
|
||||
while ((($intpart / 2) != 0) && ($i >= 0))
|
||||
{
|
||||
$real_significand_bin[$i] = $intpart % 2;
|
||||
if (($intpart % 2) == 0) $intpart = $intpart / 2;
|
||||
else $intpart = $intpart / 2 - 0.5;
|
||||
$i -= 1;
|
||||
}
|
||||
//convert decimal part
|
||||
$i = $bias+1;
|
||||
while (($decpart > 0) && ($i < $cnst))
|
||||
{
|
||||
$decpart *= 2;
|
||||
if ($decpart >= 1) {
|
||||
$real_significand_bin[$i] = 1;
|
||||
$decpart --;
|
||||
$i++;
|
||||
}
|
||||
else
|
||||
{
|
||||
$real_significand_bin[i] = 0;
|
||||
$i++;
|
||||
}
|
||||
}
|
||||
//obtain exponent value
|
||||
$i = 0;
|
||||
//find most significant bit of significand
|
||||
while (($i < $cnst) && ($real_significand_bin[$i] != 1)) $i++;
|
||||
//
|
||||
$index_exp = $i;
|
||||
$real_exponent = 128 - $index_exp;
|
||||
if ($real_exponent < -126) return 0;
|
||||
if (($real_exponent > 127)&&($real_float>0)) return 0x7F7FFFFF;
|
||||
if (($real_exponent > 127)&&($real_float<0)) return 0xFF7FFFFF;
|
||||
for ($i=0; $i<23; $i++)
|
||||
$real_significand = $real_significand + $real_significand_bin[$index_exp+1+$i] * $two_power_x[22-$i];
|
||||
// return
|
||||
if ($value<0) $w = 0x80000000 + ($real_significand & 0x7FFFFF) + ((($real_exponent+127)<<23) & 0x7F800000);
|
||||
else $w = ($real_significand & 0x7FFFFF) + ((($real_exponent+127)<<23) & 0x7F800000);
|
||||
return $w;
|
||||
}
|
||||
|
||||
/**
|
||||
* endianness
|
||||
*
|
||||
* Make endianess as required.
|
||||
* For more see http://en.wikipedia.org/wiki/Endianness
|
||||
*
|
||||
* @param int $value
|
||||
* @param bool $endianness
|
||||
* @return int
|
||||
*/
|
||||
private function endianness($value, $endianness = 0){
|
||||
if ($endianness == 0)
|
||||
return
|
||||
self::iecBYTE(($value >> 8) & 0x000000FF) .
|
||||
self::iecBYTE(($value & 0x000000FF)) .
|
||||
self::iecBYTE(($value >> 24) & 0x000000FF) .
|
||||
self::iecBYTE(($value >> 16) & 0x000000FF);
|
||||
else
|
||||
return
|
||||
self::iecBYTE(($value >> 24) & 0x000000FF) .
|
||||
self::iecBYTE(($value >> 16) & 0x000000FF) .
|
||||
self::iecBYTE(($value >> 8) & 0x000000FF) .
|
||||
self::iecBYTE(($value & 0x000000FF));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
@@ -0,0 +1,557 @@
|
||||
<?php
|
||||
/**
|
||||
* Phpmodbus Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
*
|
||||
* This source file is subject to the "PhpModbus license" that is bundled
|
||||
* with this package in the file license.txt.
|
||||
*
|
||||
*
|
||||
* @copyright Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
* @license PhpModbus license
|
||||
* @category Phpmodbus
|
||||
* @tutorial Phpmodbus.pkg
|
||||
* @package Phpmodbus
|
||||
* @version $id$
|
||||
*
|
||||
*/
|
||||
|
||||
require_once dirname(__FILE__) . '/IecType.php';
|
||||
require_once dirname(__FILE__) . '/PhpType.php';
|
||||
|
||||
/**
|
||||
* ModbusMasterUdp
|
||||
*
|
||||
* This class deals with the MODBUS master using UDP stack.
|
||||
*
|
||||
* Implemented MODBUS functions:
|
||||
* - FC 3: read multiple registers
|
||||
* - FC 16: write multiple registers
|
||||
* - FC 23: read write registers
|
||||
*
|
||||
* @author Jan Krakora
|
||||
* @copyright Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
* @package Phpmodbus
|
||||
*
|
||||
*/
|
||||
class ModbusMasterUdp {
|
||||
var $sock;
|
||||
var $port = "502";
|
||||
var $host = "192.168.1.1";
|
||||
var $errstr;
|
||||
var $status;
|
||||
var $timeout_sec = 5; // 5 sec
|
||||
var $endianess = 0; // defines endian codding (little endian == 0, big endian == 1)
|
||||
|
||||
/**
|
||||
* Modbus
|
||||
*
|
||||
* This is the constructor that defines {@link $host} IP address of the object.
|
||||
*
|
||||
* @param String $host An IP address of a Modbus TCP device. E.g. "192.168.1.1".
|
||||
*/
|
||||
function ModbusMasterUdp($host){
|
||||
$this->host = $host;
|
||||
}
|
||||
|
||||
/**
|
||||
* connect
|
||||
*
|
||||
* Connect the socket
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
private function connect(){
|
||||
// UDP socket
|
||||
$this->sock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
|
||||
// connect
|
||||
$result = @socket_connect($this->sock, $this->host, $this->port);
|
||||
if ($result === false) {
|
||||
$this->errstr .= "socket_connect() failed.</br>Reason: ($result) " .
|
||||
socket_strerror(socket_last_error($this->sock));
|
||||
return false;
|
||||
} else {
|
||||
$this->status .= "Connected</br>";
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* disconnect
|
||||
*
|
||||
* Disconnect the socket
|
||||
*/
|
||||
private function disconnect(){
|
||||
socket_close($this->sock);
|
||||
$this->status .= "Disconnected</br>";
|
||||
}
|
||||
|
||||
/**
|
||||
* send
|
||||
*
|
||||
* Send the packet via Modbus
|
||||
*
|
||||
* @param string $packet
|
||||
*/
|
||||
private function send($packet){
|
||||
socket_write($this->sock, $packet, strlen($packet));
|
||||
$this->status .= "Send</br>";
|
||||
}
|
||||
|
||||
/**
|
||||
* rec
|
||||
*
|
||||
* Receive data from the socket
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
private function rec(){
|
||||
socket_set_nonblock($this->sock);
|
||||
$readsocks[] = $this->sock;
|
||||
$writesocks = NULL;
|
||||
$exceptsocks = NULL;
|
||||
$rec = "";
|
||||
$lastAccess = time();
|
||||
while (socket_select($readsocks,
|
||||
$writesocks,
|
||||
$exceptsocks,
|
||||
0,
|
||||
300000) !== FALSE) {
|
||||
$this->status .= "Wait received data</br>";
|
||||
if (in_array($this->sock, $readsocks)) {
|
||||
while (@socket_recv($this->sock, $rec, 2000, 0)) {
|
||||
$this->status .= "Received</br>";
|
||||
return $rec;
|
||||
}
|
||||
$lastAccess = time();
|
||||
} else {
|
||||
if (time()-$lastAccess >= $this->timeout_sec) {
|
||||
$this->errstr .= "Watchdog time expired [ " .
|
||||
$this->timeout_sec . " sec]!!! Connection to " .
|
||||
$this->host . " is not established.";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
$readsocks[] = $this->sock;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* responseCode
|
||||
*
|
||||
* Check the Modbus response code
|
||||
*
|
||||
* @param string $packet
|
||||
* @return bool
|
||||
*/
|
||||
private function responseCode($packet){
|
||||
if(($packet[7] & 0x80) > 0) {
|
||||
$this->errstr .= "Modbus response error code:" . ord($packet[8]);
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
$this->status .= "Modbus response error code: NOERROR</br>";
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* readMultipleRegisters
|
||||
*
|
||||
* Modbus function FC 3(0x03) - Read Multiple Registers.
|
||||
*
|
||||
* This function reads {@link $quantity} of Words (2 bytes) from reference
|
||||
* {@link $referenceRead} of a memory of a Modbus device given by
|
||||
* {@link $unitId}.
|
||||
*
|
||||
*
|
||||
* @param int $unitId usually ID of Modbus device
|
||||
* @param int $reference Reference in the device memory to read data (e.g. in device WAGO 750-841, memory MW0 starts at address 12288).
|
||||
* @param int $quantity Amounth of the data to be read from device.
|
||||
* @return false|Array Success flag or array of received data.
|
||||
*/
|
||||
function readMultipleRegisters($unitId, $reference, $quantity){
|
||||
$this->errstr = "";
|
||||
$this->status = "readMultipleRegisters: START</br>";
|
||||
// connect
|
||||
if(!$this->connect())
|
||||
return false;
|
||||
// send FC 3
|
||||
$packet = $this->readMultipleRegistersPacketBuilder($unitId, $reference, $quantity);
|
||||
$this->status .= $this->printPacket($packet);
|
||||
$this->send($packet);
|
||||
// receive response
|
||||
$rpacket = $this->rec();
|
||||
if(!$rpacket)
|
||||
return false;
|
||||
$this->status .= $this->printPacket($rpacket);
|
||||
// parse packet
|
||||
$receivedData = $this->readMultipleRegistersParser($rpacket);
|
||||
if(!$receivedData)
|
||||
return false;
|
||||
// disconnect
|
||||
$this->disconnect();
|
||||
$this->status .= "readMultipleRegisters: DONE</br>";
|
||||
// return
|
||||
return $receivedData;
|
||||
}
|
||||
|
||||
/**
|
||||
* fc3
|
||||
*
|
||||
* Alias to {@link readMultipleRegisters} method.
|
||||
*
|
||||
* @param int $unitId
|
||||
* @param int $reference
|
||||
* @param int $quantity
|
||||
* @return false|Array
|
||||
*/
|
||||
function fc3($unitId, $reference, $quantity){
|
||||
return $this->readMultipleRegisters($unitId, $reference, $quantity);
|
||||
}
|
||||
|
||||
/**
|
||||
* readMultipleRegistersPacketBuilder
|
||||
*
|
||||
* Packet FC 3 builder - read multiple registers
|
||||
*
|
||||
* @param int $unitId
|
||||
* @param int $reference
|
||||
* @param int $quantity
|
||||
* @return string
|
||||
*/
|
||||
private function readMultipleRegistersPacketBuilder($unitId, $reference, $quantity){
|
||||
$dataLen = 0;
|
||||
// build body
|
||||
$buffer2 = "";
|
||||
$buffer2 .= iecType::iecBYTE(3); // FC 3 = 3(0x03)
|
||||
// build body - read section
|
||||
$buffer2 .= iecType::iecINT($reference); // refnumber = 12288
|
||||
$buffer2 .= iecType::iecINT($quantity); // quantity
|
||||
$dataLen += 5;
|
||||
// build header
|
||||
$buffer3 = '';
|
||||
$buffer3 .= iecType::iecINT(rand(0,65000)); // transaction ID
|
||||
$buffer3 .= iecType::iecINT(0); // protocol ID
|
||||
$buffer3 .= iecType::iecINT($dataLen + 1); // lenght
|
||||
$buffer3 .= iecType::iecBYTE($unitId); //unit ID
|
||||
// return packet string
|
||||
return $buffer3. $buffer2. $buffer1;
|
||||
}
|
||||
|
||||
/**
|
||||
* readMultipleRegistersParser
|
||||
*
|
||||
* FC 3 response parser
|
||||
*
|
||||
* @param string $packet
|
||||
* @return array
|
||||
*/
|
||||
private function readMultipleRegistersParser($packet){
|
||||
$data = array();
|
||||
// if not exception
|
||||
if(!$this->responseCode($packet))
|
||||
return false;
|
||||
// get data
|
||||
for($i=0;$i<ord($packet[8]);$i++){
|
||||
$data[$i] = ord($packet[9+$i]);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* writeMultipleRegister
|
||||
*
|
||||
* Modbus function FC16(0x10) - Write Multiple Register.
|
||||
*
|
||||
* This function writes {@link $data} array at {@link $reference} position of
|
||||
* memory of a Modbus device given by {@link $unitId}.
|
||||
*
|
||||
*
|
||||
* @param int $unitId usually ID of Modbus device
|
||||
* @param int $reference Reference in the device memory (e.g. in device WAGO 750-841, memory MW0 starts at address 12288)
|
||||
* @param array $data Array of values to be written.
|
||||
* @param array $dataTypes Array of types of values to be written. The array should consists of string "INT", "DINT" and "REAL".
|
||||
* @return bool Success flag
|
||||
*/
|
||||
function writeMultipleRegister($unitId, $reference, $data, $dataTypes){
|
||||
$this->errstr = "";
|
||||
$this->status = "writeMultipleRegister: START</br>";
|
||||
// connect
|
||||
if(!$this->connect())
|
||||
return false;
|
||||
// send FC16
|
||||
$packet = $this->writeMultipleRegisterPacketBuilder($unitId, $reference, $data, $dataTypes);
|
||||
$this->status .= $this->printPacket($packet);
|
||||
$this->send($packet);
|
||||
// receive response
|
||||
$rpacket = $this->rec();
|
||||
if(!$rpacket)
|
||||
return false;
|
||||
$this->status .= $this->printPacket($rpacket);
|
||||
// parse packet
|
||||
if(!$this->writeMultipleRegisterParser($rpacket))
|
||||
return false;
|
||||
// disconnect
|
||||
$this->disconnect();
|
||||
$this->status .= "writeMultipleRegister: DONE</br>";
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* fc16
|
||||
*
|
||||
* Alias to {@link writeMultipleRegister} method
|
||||
*
|
||||
* @param int $unitId
|
||||
* @param int $reference
|
||||
* @param array $data
|
||||
* @param array $dataTypes
|
||||
* @return bool
|
||||
*/
|
||||
function fc16($unitId, $reference, $data, $dataTypes){
|
||||
return $this->writeMultipleRegister($unitId, $reference, $data, $dataTypes);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* writeMultipleRegisterPacketBuilder
|
||||
*
|
||||
* Packet builder FC16 - WRITE multiple register
|
||||
* e.g.: 4dd90000000d0010300000030603e807d00bb8
|
||||
*
|
||||
* @param int $unitId
|
||||
* @param int $reference
|
||||
* @param array $data
|
||||
* @param array $dataTypes
|
||||
* @return string
|
||||
*/
|
||||
private function writeMultipleRegisterPacketBuilder($unitId, $reference, $data, $dataTypes){
|
||||
$dataLen = 0;
|
||||
// build data section
|
||||
$buffer1 = "";
|
||||
foreach($data as $key=>$dataitem) {
|
||||
if($dataTypes[$key]=="INT"){
|
||||
$buffer1 .= iecType::iecINT($dataitem); // register values x
|
||||
$dataLen += 2;
|
||||
}
|
||||
elseif($dataTypes[$key]=="DINT"){
|
||||
$buffer1 .= iecType::iecDINT($dataitem, $endianess); // register values x
|
||||
$dataLen += 4;
|
||||
}
|
||||
elseif($dataTypes[$key]=="REAL") {
|
||||
$buffer1 .= iecType::iecREAL($dataitem, $endianess); // register values x
|
||||
$dataLen += 4;
|
||||
}
|
||||
else{
|
||||
$buffer1 .= iecType::iecINT($dataitem); // register values x
|
||||
$dataLen += 2;
|
||||
}
|
||||
}
|
||||
// build body
|
||||
$buffer2 = "";
|
||||
$buffer2 .= iecType::iecBYTE(16); // FC 16 = 16(0x10)
|
||||
$buffer2 .= iecType::iecINT($reference); // refnumber = 12288
|
||||
$buffer2 .= iecType::iecINT($dataLen/2); // word count
|
||||
$buffer2 .= iecType::iecBYTE($dataLen); // byte count
|
||||
$dataLen += 6;
|
||||
// build header
|
||||
$buffer3 = '';
|
||||
$buffer3 .= iecType::iecINT(rand(0,65000)); // transaction ID
|
||||
$buffer3 .= iecType::iecINT(0); // protocol ID
|
||||
$buffer3 .= iecType::iecINT($dataLen + 1); // lenght
|
||||
$buffer3 .= iecType::iecBYTE($unitId); //unit ID
|
||||
|
||||
// return packet string
|
||||
return $buffer3. $buffer2. $buffer1;
|
||||
}
|
||||
|
||||
/**
|
||||
* writeMultipleRegisterParser
|
||||
*
|
||||
* FC16 response parser
|
||||
*
|
||||
* @param string $packet
|
||||
* @return bool
|
||||
*/
|
||||
private function writeMultipleRegisterParser($packet){
|
||||
if(!$this->responseCode($rpacket))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* readWriteRegisters
|
||||
*
|
||||
* Modbus function FC23(0x17) - Read Write Registers.
|
||||
*
|
||||
* This function writes {@link $data} array at reference {@link $referenceWrite}
|
||||
* position of memory of a Modbus device given by {@link $unitId}. Simultanously,
|
||||
* it returns {@link $quantity} of Words (2 bytes) from reference {@link $referenceRead}.
|
||||
*
|
||||
*
|
||||
* @param int $unitId usually ID of Modbus device
|
||||
* @param int $referenceRead Reference in the device memory to read data (e.g. in device WAGO 750-841, memory MW0 starts at address 12288).
|
||||
* @param int $quantity Amounth of the data to be read from device.
|
||||
* @param int $referenceWrite Reference in the device memory to write data.
|
||||
* @param array $data Array of values to be written.
|
||||
* @param array $dataTypes Array of types of values to be written. The array should consists of string "INT", "DINT" and "REAL".
|
||||
* @return false|Array Success flag or array of data.
|
||||
*/
|
||||
function readWriteRegisters($unitId, $referenceRead, $quantity, $referenceWrite, $data, $dataTypes){
|
||||
$this->errstr = "";
|
||||
$this->status = "readWriteRegisters: START</br>";
|
||||
// connect
|
||||
if(!$this->connect())
|
||||
return false;
|
||||
// send FC23
|
||||
$packet = $this->readWriteRegistersPacketBuilder($unitId, $referenceRead, $quantity, $referenceWrite, $data, $dataTypes);
|
||||
$this->status .= $this->printPacket($packet);
|
||||
$this->send($packet);
|
||||
// receive response
|
||||
$rpacket = $this->rec();
|
||||
if(!$rpacket)
|
||||
return false;
|
||||
$this->status .= $this->printPacket($rpacket);
|
||||
// parse packet
|
||||
$receivedData = $this->readWriteRegistersParser($rpacket);
|
||||
if(!$receivedData)
|
||||
return false;
|
||||
// disconnect
|
||||
$this->disconnect();
|
||||
$this->status .= "writeMultipleRegister: DONE</br>";
|
||||
// return
|
||||
return $receivedData;
|
||||
}
|
||||
|
||||
/**
|
||||
* fc23
|
||||
*
|
||||
* Alias to {@link readWriteRegisters} method.
|
||||
*
|
||||
* @param int $unitId
|
||||
* @param int $referenceRead
|
||||
* @param int $quantity
|
||||
* @param int $referenceWrite
|
||||
* @param array $data
|
||||
* @param array $dataTypes
|
||||
* @return false|Array
|
||||
*/
|
||||
function fc23($unitId, $referenceRead, $quantity, $referenceWrite, $data, $dataTypes){
|
||||
return $this->readWriteRegisters($unitId, $referenceRead, $quantity, $referenceWrite, $data, $dataTypes);
|
||||
}
|
||||
|
||||
/**
|
||||
* readWriteRegistersPacketBuilder
|
||||
*
|
||||
* Packet FC23 builder - READ WRITE registers
|
||||
*
|
||||
*
|
||||
* @param int $unitId
|
||||
* @param int $referenceRead
|
||||
* @param int $quantity
|
||||
* @param int $referenceWrite
|
||||
* @param array $data
|
||||
* @param array $dataTypes
|
||||
* @return string
|
||||
*/
|
||||
private function readWriteRegistersPacketBuilder($unitId, $referenceRead, $quantity, $referenceWrite, $data, $dataTypes){
|
||||
$dataLen = 0;
|
||||
// build data section
|
||||
$buffer1 = "";
|
||||
foreach($data as $key => $dataitem) {
|
||||
if($dataTypes[$key]=="INT"){
|
||||
$buffer1 .= iecType::iecINT($dataitem); // register values x
|
||||
$dataLen += 2;
|
||||
}
|
||||
elseif($dataTypes[$key]=="DINT"){
|
||||
$buffer1 .= iecType::iecDINT($dataitem, $endianess); // register values x
|
||||
$dataLen += 4;
|
||||
}
|
||||
elseif($dataTypes[$key]=="REAL") {
|
||||
$buffer1 .= iecType::iecREAL($dataitem, $endianess); // register values x
|
||||
$dataLen += 4;
|
||||
}
|
||||
else{
|
||||
$buffer1 .= iecType::iecINT($dataitem); // register values x
|
||||
$dataLen += 2;
|
||||
}
|
||||
}
|
||||
// build body
|
||||
$buffer2 = "";
|
||||
$buffer2 .= iecType::iecBYTE(23); // FC 23 = 23(0x17)
|
||||
// build body - read section
|
||||
$buffer2 .= iecType::iecINT($referenceRead); // refnumber = 12288
|
||||
$buffer2 .= iecType::iecINT($quantity); // quantity
|
||||
// build body - write section
|
||||
$buffer2 .= iecType::iecINT($referenceWrite); // refnumber = 12288
|
||||
$buffer2 .= iecType::iecINT($dataLen/2); // word count
|
||||
$buffer2 .= iecType::iecBYTE($dataLen); // byte count
|
||||
$dataLen += 10;
|
||||
// build header
|
||||
$buffer3 = '';
|
||||
$buffer3 .= iecType::iecINT(rand(0,65000)); // transaction ID
|
||||
$buffer3 .= iecType::iecINT(0); // protocol ID
|
||||
$buffer3 .= iecType::iecINT($dataLen + 1); // lenght
|
||||
$buffer3 .= iecType::iecBYTE($unitId); //unit ID
|
||||
|
||||
// return packet string
|
||||
return $buffer3. $buffer2. $buffer1;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* readWriteRegistersParser
|
||||
*
|
||||
* FC23 response parser
|
||||
*
|
||||
* @param string $packet
|
||||
* @return array
|
||||
*/
|
||||
private function readWriteRegistersParser($packet){
|
||||
$data = array();
|
||||
// if not exception
|
||||
if(!$this->responseCode($packet))
|
||||
return false;
|
||||
// get data
|
||||
for($i=0;$i<ord($packet[8]);$i++){
|
||||
$data[$i] = ord($packet[9+$i]);
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* byte2hex
|
||||
*
|
||||
* Parse data and get it to the Hex form
|
||||
*
|
||||
* @param char $value
|
||||
* @return string
|
||||
*/
|
||||
private function byte2hex($value){
|
||||
$h = dechex(($value >> 4) & 0x0F);
|
||||
$l = dechex($value & 0x0F);
|
||||
return "$h$l";
|
||||
}
|
||||
|
||||
/**
|
||||
* printPacket
|
||||
*
|
||||
* Print whole packet in the hex form
|
||||
*
|
||||
* @param string $packet
|
||||
* @return string
|
||||
*/
|
||||
private function printPacket($packet){
|
||||
$str = "";
|
||||
$str .= "Packet: ";
|
||||
for($i=0;$i<strlen($packet);$i++){
|
||||
$str .= $this->byte2hex(ord($packet[$i]));
|
||||
}
|
||||
$str .= "</br>";
|
||||
return $str;
|
||||
}
|
||||
}
|
||||
|
||||
?>
|
||||
@@ -0,0 +1,219 @@
|
||||
<?
|
||||
/**
|
||||
* Phpmodbus Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
*
|
||||
* This source file is subject to the "PhpModbus license" that is bundled
|
||||
* with this package in the file license.txt.
|
||||
*
|
||||
* @author Jan Krakora
|
||||
* @copyright Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
* @license PhpModbus license
|
||||
* @category Phpmodbus
|
||||
* @package Phpmodbus
|
||||
* @version $id$
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* PhpType
|
||||
*
|
||||
* The class includes set of methods that convert the received Modbus data
|
||||
* (array of bytes) to the PHP data type, i.e. signed int, unsigned int and float.
|
||||
*
|
||||
* @author Jan Krakora
|
||||
* @copyright Copyright (c) 2004, 2009 Jan Krakora, WAGO Kontakttechnik GmbH & Co. KG (http://www.wago.com)
|
||||
* @package Phpmodbus
|
||||
*
|
||||
*/
|
||||
class PhpType {
|
||||
|
||||
/**
|
||||
* bytes2float
|
||||
*
|
||||
* The function converts array of 4 bytes to float. The return value
|
||||
* depends on order of the input bytes (endianning).
|
||||
*
|
||||
* @param array $values
|
||||
* @param bool $endianness
|
||||
* @return float
|
||||
*/
|
||||
public static function bytes2float($values, $endianness = 0){
|
||||
$data = array();
|
||||
$real = 0;
|
||||
|
||||
// Set the array to correct form
|
||||
$data = self::checkData($values);
|
||||
// Combine bytes
|
||||
$real = self::combineBytes($data, $endianness);
|
||||
// Convert the real value to float
|
||||
return (float) self::real2float($real);
|
||||
}
|
||||
|
||||
/**
|
||||
* bytes2signedInt
|
||||
*
|
||||
* The function converts array of 2 or 4 bytes to signed integer.
|
||||
* The return value depends on order of the input bytes (endianning).
|
||||
*
|
||||
* @param array $values
|
||||
* @param bool $endianness
|
||||
* @return int
|
||||
*/
|
||||
public static function bytes2signedInt($values, $endianness = 0){
|
||||
$data = array();
|
||||
$int = 0;
|
||||
// Set the array to correct form
|
||||
$data = self::checkData($values);
|
||||
// Combine bytes
|
||||
$int = self::combineBytes($data, $endianness);
|
||||
// In the case of signed 2 byte value convert it to 4 byte one
|
||||
if ((count($values) == 2) && ((0x8000 & $int) > 0)){
|
||||
$int = 0xFFFF8000 | $int;
|
||||
}
|
||||
// Convert the value
|
||||
return (int) self::dword2signedInt($int);
|
||||
}
|
||||
|
||||
/**
|
||||
* bytes2unsignedInt
|
||||
*
|
||||
* The function converts array of 2 or 4 bytes to unsigned integer.
|
||||
* The return value depends on order of the input bytes (endianning).
|
||||
*
|
||||
* @param array $values
|
||||
* @param bool $endianness
|
||||
* @return int|float
|
||||
*/
|
||||
public static function bytes2unsignedInt($values, $endianness = 0){
|
||||
$data = array();
|
||||
$int = 0;
|
||||
// Set the array to correct form
|
||||
$data = self::checkData($values);
|
||||
// Combine bytes
|
||||
$int = self::combineBytes($data, $endianness);
|
||||
// Convert the value
|
||||
return self::dword2unsignedInt($int);
|
||||
}
|
||||
|
||||
/**
|
||||
* real2float
|
||||
*
|
||||
* This function converts a value in IEC-1131 REAL single precision form to float.
|
||||
*
|
||||
* For more see [{@link http://en.wikipedia.org/wiki/Single_precision Single precision on Wiki}] or
|
||||
* [{@link http://de.php.net/manual/en/function.base-convert.php PHP base_convert function commentary}, Todd Stokes @ Georgia Tech 21-Nov-2007]
|
||||
*
|
||||
* @param value value in IEC REAL data type to be converted
|
||||
* @return float float value
|
||||
*/
|
||||
private static function real2float($value){
|
||||
$two_pow_minus_x = array(
|
||||
1, 0.5, 0.25, 0.125, 0.0625, 0.03125, 0.015625,
|
||||
0.0078125, 0.00390625, 0.001953125, 0.0009765625,
|
||||
0.00048828125, 0.000244140625, 0.0001220703125,
|
||||
0.00006103515625, 0.000030517578125, 0.0000152587890625,
|
||||
0.00000762939453125, 0.000003814697265625, 0.0000019073486328125,
|
||||
0.00000095367431640625, 0.000000476837158203125,
|
||||
0.0000002384185791015625, 0.00000011920928955078125);
|
||||
// get sign, mantisa, exponent
|
||||
$real_mantisa = $value & 0x7FFFFF | 0x800000;
|
||||
$real_exponent = ($value>>23) & 0xFF;
|
||||
$real_sign = ($value>>31) & 0x01;
|
||||
$bin_exponent = $real_exponent - 127;
|
||||
// decode value
|
||||
if (( $bin_exponent >= -126) && ($bin_exponent <= 127)) {
|
||||
// Mantissa decoding
|
||||
for ($i=0; $i<24; $i++) {
|
||||
if ($real_mantisa & 0x01)
|
||||
$val += $two_pow_minus_x[23-$i];
|
||||
$real_mantisa = $real_mantisa >> 1;
|
||||
}
|
||||
// Base
|
||||
$val = $val * pow(2,$bin_exponent);
|
||||
if (($real_sign == 1)) $val = -$val;
|
||||
}
|
||||
return (float)$val;
|
||||
}
|
||||
|
||||
/**
|
||||
* dword2signedInt
|
||||
*
|
||||
* Switch double word to signed integer
|
||||
*
|
||||
* @param int $value
|
||||
* @return int
|
||||
*/
|
||||
private static function dword2signedInt($value){
|
||||
if ((0x80000000 & $value) != 0) {
|
||||
return -(0x7FFFFFFF & ~$value)-1;
|
||||
} else {
|
||||
return (0x7FFFFFFF & $value);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* dword2signedInt
|
||||
*
|
||||
* Switch double word to unsigned integer
|
||||
*
|
||||
* @param int $value
|
||||
* @return int|float
|
||||
*/
|
||||
private static function dword2unsignedInt($value){
|
||||
if ((0x80000000 & $value) != 0) {
|
||||
return ((float) (0x7FFFFFFF & $value)) + 2147483648;
|
||||
} else {
|
||||
return (int) (0x7FFFFFFF & $value);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* checkData
|
||||
*
|
||||
* Check if the data variable is array, and check if the values are numeric
|
||||
*
|
||||
* @param int $data
|
||||
* @return int
|
||||
*/
|
||||
private static function checkData($data){
|
||||
// Check the data
|
||||
if (!is_array($data)) {
|
||||
throw new Exception('The input data should be an array of bytes.');
|
||||
}
|
||||
// Check the values to be number - must be
|
||||
if (!is_numeric($data[0]) || !is_numeric($data[1])) {
|
||||
throw new Exception('Data are not numeric.');
|
||||
}
|
||||
if (!is_numeric($data[2])) $data[2] = 0;
|
||||
if (!is_numeric($data[3])) $data[3] = 0;
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* combineBytes
|
||||
*
|
||||
* Combine bytes together
|
||||
*
|
||||
* @param int $data
|
||||
* @param bool $endianness
|
||||
* @return int
|
||||
*/
|
||||
private static function combineBytes($data, $endianness){
|
||||
$value = 0;
|
||||
// Combine bytes
|
||||
if ($endianness == 0)
|
||||
$value = (($data[3] & 0xFF)<<16) |
|
||||
(($data[2] & 0xFF)<<24) |
|
||||
(($data[1] & 0xFF)) |
|
||||
(($data[0] & 0xFF)<<8);
|
||||
else
|
||||
$value = (($data[3] & 0xFF)<<24) |
|
||||
(($data[2] & 0xFF)<<16) |
|
||||
(($data[1] & 0xFF)<<8) |
|
||||
(($data[0] & 0xFF));
|
||||
|
||||
return $value;
|
||||
}
|
||||
}
|
||||
?>
|
||||
Reference in New Issue
Block a user