Posprint\Extras\PhpSerial

Complexity

Total Complexity

84

Size/Duplication

Total Lines	713
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

54.4%

Importance

Changes	1
Bugs	0	Features	0

31 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	12	5
A	clearParams()	0	17	1
A	__destruct()	0	4	1
A	open()	0	18	4
A	close()	0	12	4
B	config()	0	29	3
A	setAuto()	0	11	3
A	getAuto()	0	4	1
A	read()	0	4	1
A	write()	0	9	2
A	flush()	0	8	2
C	setPort()	0	22	10
A	getPort()	0	4	1
A	getDevice()	0	4	1
A	setDataBits()	0	9	3
A	getDataBits()	0	4	1
A	zDataBits()	0	9	2
A	setBaudRate()	0	9	2
A	getBaudRate()	0	4	1
A	zBaudRate()	0	9	2
A	setParity()	0	9	2
A	getParity()	0	11	4
A	zParity()	0	9	2
A	setStopBits()	0	9	4
A	getStopBits()	0	4	1
A	zStopBits()	0	8	3
A	setFlowControl()	0	15	3
A	getFlowControl()	0	11	4
A	zFlowControl()	0	20	1
B	getOs()	0	21	8
A	execCommand()	0	17	2

<?php

namespace Posprint\Extras;

/**
 * Serial port control class
 *
 * Refactoring from original, https://github.com/Xowap/PHP-Serial, to meet PSR standards
 * and propose improvements and fixes to the fact that the original is not actively
 * maintained for many years.
 * by Roberto L. Machado <linux dot rlm at gmail dot com>
 * 
 * IMPORTANT: check and adjust permissions for serial port access by server user like www-data
 * 
 * @author Rémy Sanchez <remy.sanchez@hyperthese.net>
 * @author Rizwan Kassim <rizwank@geekymedia.com>
 * @thanks Aurélien Derouineau for finding how to open serial ports with windows
 * @thanks Alec Avedisyan for help and testing with reading
 * @thanks Jim Wright for OSX cleanup/fixes.
 * @copyright under GPL 2 licence
 */

use RuntimeException;
use InvalidArgumentException;

class PhpSerial
{
    const OS_UNKNOWN = 0;
    const OS_WIN = 1; //WINS32 WINNT Windows
    const OS_LINUX = 2;
    const OS_CYGWIN = 3; //Cygwin Windows Linux like commands
    const OS_UNIX = 4;
    const OS_BSD = 5; //FreeBSD or NetBSD or OpenBSD /dev/ttyu1
    const OS_OSX = 6; //Darwin MacOS
    const OS_HPUX = 7; //tty1p0
    const SERIAL_DEVICE_NOTSET = 0;
    const SERIAL_DEVICE_SET = 1;
    const SERIAL_DEVICE_OPENED = 2;
    const PARITY_NONE = 0;
    const PARITY_ODD = 1;
    const PARITY_EVEN = 2;
    const FLOW_NONE = 0; //no flow control
    const FLOW_RTSCTS = 1; // use RTS/CTS handshaking
    const FLOW_XONXOFF = 2; //use XON/XOFF protocol
    
    /**
     * Pointer for device
     * 
     * @var resource
     */
    protected $handle = null;
    /**
     * Data buffer
     * 
     * @var string
     */
    protected $buffer = "";
    /**
     * This var says if buffer should be flushed by write (true) or
     * manually (false)
     *
     * @var bool
     */
    protected $autoflush = false;
    /**
     * Wait time after send data to serial
     * 
     * @var float
     */
    protected $waittime = 0.1;
    /**
     * OS type where php is running
     * 
     * @var int
     */
    protected $ostype = 2; //linux is default
    /**
     * Mode command to set up serial port
     * 
     * @var string
     */
    protected $mode = ''; //formated device mode for especific OS use
    /**
     * Status of port
     * NoSet, Set or Open
     * 
     * @var int
     */
    protected $state = self::SERIAL_DEVICE_NOTSET;
    /**
     * Port name
     * 
     * @var string
     */
    protected $port = '/dev/ttyS0';
    /**
     * Data bits
     * 
     * @var int
     */
    protected $databits = 8;
    /**
     * Baud Rate
     * 
     * @var int 
     */
    protected $baudrate = 9600;
    /**
     * Parity
     * 
     * @var int
     */
    protected $parity = self::PARITY_NONE;
    /**
     * Stop Bits
     * 
     * @var float
     */
    protected $stopbits = 1;
    /**
     * Flow Control
     * 
     * @var int
     */
    protected $flowcontrol = self::FLOW_NONE;
    /**
     * Formated device name command
     * 
     * @var string
     */
    protected $device = '/dev/ttyS0';
    /**
     * Formated Data Bits command
     * 
     * @var string
     */
    protected $formatedDataBits = 'cs8';
    /**
     * Formated Baud Rate command
     * 
     * @var string
     */
    protected $formatedBaudRate = '9600';
    /**
     * Formated parity command
     * 
     * @var string
     */
    protected $formatedParity = '-parenb';
    /**
     * Formated stop bits command
     * 
     * @var string
     */
    protected $formatedStopBits = '-cstopb';
    /**
     * Formated flow control command
     * 
     * @var string
     */
    protected $formatedFlowControl = 'clocal -crtscts -ixon -ixoff';
    
    /**
     * Parity data
     * 
     * @var array
     */
    private $parityargs = [
        "none" => [0, "-parenb"],
        "odd"  => [1, "parenb parodd"],
        "even" => [2, "parenb -parodd"]
    ];
    
    /**
     * Basud Rate data
     * 
     * @var array
     */
    private $baudsargs = array (
        110    => 11,
        150    => 15,
        300    => 30,
        600    => 60,
        1200   => 12,
        2400   => 24,
        4800   => 48,
        9600   => 96,
        19200  => 19,
        38400  => 38400,
        57600  => 57600,
        115200 => 115200
    );

    /**
     * Constructor
     * Set ostype parameter
     * 
     * @param int $forceOS
     */
    public function __construct($forceOS = null)
    {
        if (! is_null($forceOS)) {
            if ($this->ostype !== $forceOS && ($forceOS > 0 && $forceOS < 8)) {
                $this->ostype = $forceOS;
                //clear params
                $this->clearParams();
            }
        } else {
            $this->ostype = $this->getOs();
        }
    }
    
    /**
     * Clear class params
     * Used for testing proporses
     */
    protected function clearParams()
    {
        $this->mode = null;
        $this->state = null;
        $this->port = null;
        $this->databits = null;
        $this->baudrate = null;
        $this->parity = null;
        $this->stopbits = null;
        $this->flowcontrol = null;
        $this->device = null;
        $this->formatedDataBits = null;
        $this->formatedBaudRate = null;
        $this->formatedParity = null;
        $this->formatedStopBits = null;
        $this->formatedFlowControl = null;
    }

    /**
     * Close port
     */
    public function __destruct()
    {
        $this->close();
    }
    
    /**
     * Open set port
     * 
     * @return boolean
     */
    public function open()
    {
        if ($this->state === self::SERIAL_DEVICE_OPENED && is_resource($this->handle)) {
            return true;
        }
        //before the serial port is opened it must be configured,
        //and in windows environment, all sets at a single time
        $this->config();

The call to the method Posprint\Extras\PhpSerial::config() seems un-needed as the method has no side-effects.

        $this->handle = @fopen($this->device, 'r+b');
        if ($this->handle === false) {
            $this->handle = null;
            $this->state = self::SERIAL_DEVICE_NOTSET;
            throw new RuntimeException('Fail to open device. Check permissions.');
        }
        stream_set_blocking($this->handle, false);
        $this->state = self::SERIAL_DEVICE_OPENED;
        return true;
    }
    
    /**
     * Close serial port
     * 
     * @return boolean
     */
    public function close()
    {
        if ($this->state !== self::SERIAL_DEVICE_OPENED || ! is_resource($this->handle)) {
            return true;
        }
        if (fclose($this->handle)) {
            $this->handle = null;
            $this->state = self::SERIAL_DEVICE_SET;
            return true;
        }
        return false;
    }
    
    /**
     * Use class parameters to configure the serial port
     */
    public function config()
    {
        if ($this->state === self::SERIAL_DEVICE_SET) {
            return true;
        }
        if ($this->ostype == 0) {
            return false;
        }
        $modesos = [
            1 => 'MODE', //windos mode com4: BAUD=9600 PARITY=n DATA=8 STOP=1 to=off dtr=off rts=off
            2 => "stty -F", //linux
            3 => "stty -F", //cygwin
            4 => 'stty -F', //unix
            5 => 'stty -F', //BSD
            6 => "stty -f", //MacOS
            7 => 'stty -F' //HPUX
        ];

        $mode = $modesos[$this->ostype]
                . " "
                . "$this->device "
                . "$this->formatedBaudRate "
                . "$this->formatedParity "
                . "$this->formatedDataBits "
                . "$this->formatedStopBits "
                . "$this->formatedFlowControl";
        
        return $mode;
    }
    
    /**
     * Set automatic send massage to serial
     * 
     * @param bool $auto
     * @param float $time

There is no parameter named $time. Was it maybe removed?

     */
    public function setAuto($auto, $waittime)
    {
        if (! is_bool($auto)) {
            $data = false;

$data is not used, you could remove the assignment.

        }
        if (! is_float($waittime)) {
            $time = 0.1;

$time is not used, you could remove the assignment.

        }
        $this->waittime = $waittime;
        $this->autoflush = $auto;
    }
    
    /**
     * Returns automatic mode
     * 
     * @return bool
     */
    public function getAuto()
    {
        return $this->autoflush;
    }

    /**
     * Read serial port
     * 
     * @return string
     */
    public function read()
    {
        return '';
    }
    
    /**
     * Write data to buffer or serial port
     * depends of getAuto()
     * if  getAuto() == true this command writes directly to port
     * if  getAuto() == false this command writes to buffer (default)
     * 
     * @param string $data
     * @return boolean
     */
    public function write($data)
    {
        $this->buffer .= $data;
        if ($this->autoflush === true) {
            $this->flush();
            usleep((int) ($this->waittime * 1000000));
        }
        return true;
    }
    
    /**
     * Flushs imediatly data to serial port
     * 
     * @return boolean
     */
    public function flush()
    {
        if (fwrite($this->handle, $this->buffer) !== false) {
            $this->buffer = "";
            return true;
        }
        return false;
    }

    /**
     * Set port name
     * 
     * @param string $port
     */
    public function setPort($port)
    {
        //identify input if $port like COM?? even in others OS
        $flagWinMode = preg_match("@^COM(\d+):?$@i", $port, $matches);
        //select port from OS type
        switch ($this->ostype) {
            case self::OS_WIN:
                $this->device = ($flagWinMode) ? "COM$matches[1]:" : $port;
                break;
            case self::OS_LINUX:
            case self::OS_CYGWIN:
                $this->device = ($flagWinMode) ? "/dev/ttyS".($matches[1]-1) : $port;
                break;
            case self::OS_UNIX:
            case self::OS_BSD:
            case self::OS_OSX:
            case self::OS_HPUX:
            default:
                $this->device = $port;
        }
        $this->port = $port;
    }
    
    /**
     * Returns port name
     *  
     * @return string
     */
    public function getPort()
    {
        return $this->port;
    }
    
    /**
     * Returns device formated name
     * 
     * @return string
     */
    public function getDevice()
    {
        return $this->device;
    }
    
    /**
     * Sets the length of a character.
     * length of a character (5 <= length <= 8)
     * 
     * @param int $length
     * @return boolean
     */
    public function setDataBits($length)
    {
        if ($length < 5 || $length > 8) {
            $length = 8;
        }
        $this->databits = $length;
        $this->formatedDataBits = $this->zDataBits($length);
        return true;
    }
    
    /**
     * Returns char length
     * 
     * @return int
     */
    public function getDataBits()
    {
        return $this->databits;
    }
    
    /**
     * Format data bits commands
     * 
     * @param int $length
     * @return string
     */
    protected function zDataBits($length)
    {
        $fdatabits = "cs$length";
        if ($this->ostype == self::OS_WIN) {
            //windows
            $fdatabits = "DATA=$length";
        }
        return $fdatabits;
    }

    /**
     * Set serial baud rate
     * 
     * @param int $rate
     * @return boolean
     */
    public function setBaudRate($rate)
    {
        if (! isset($this->baudsargs[$rate])) {
            $rate = 9600;
        }
        $this->baudrate = $rate;
        $this->formatedBaudRate = $this->zBaudRate($rate);
        return true;
    }
    
    /**
     * Return baud rate
     * 
     * @return int
     */
    public function getBaudRate()
    {
        return $this->baudrate;
    }
    
    /**
     * Format baud rate command
     * 
     * @param int $rate
     * @return string
     */
    protected function zBaudRate($rate)
    {
        $baud = "$rate";
        if ($this->ostype == self::OS_WIN) {
            //windows
            $baud = "BAUD=".$this->baudsargs[$rate];
        }
        return $baud;
    }


    /**
     * Sets parity mode
     * 
     * @param string $parity odd, even, none
     * @return boolean
     */
    public function setParity($parity)
    {
        if (! isset($this->parityargs[$parity])) {
            $parity = 'none';
        }
        $this->parity = $this->parityargs[$parity][0];
        $this->formatedParity = $this->zParity($parity);
        return true;
    }
    
    /**
     * Get parity mode set
     * 
     * @return string
     */
    public function getParity()
    {
        switch ($this->parity) {
            case 0:
                return 'none';
            case 1:
                return 'odd';
            case 2:
                return 'even';
        }
    }
    
    /**
     * Format parity command
     * 
     * @param string $parity
     * @return string
     */
    protected function zParity($parity)
    {
        $fparity = $this->parityargs[$parity][1];
        if ($this->ostype == self::OS_WIN) {
            //windows
            $fparity = "PARITY=" .  strtoupper(substr($parity, 0, 1));
        }
        return $fparity;
    }


    /**
     * Set length of stop bits
     * the length of a stop bit.
     * It must be either 1, 1.5 or 2.
     * 1.5 is not supported under linux and on some computers.
     * 
     * @param float $length
     * @return boolean
     */
    public function setStopBits($length)
    {
        if ($length !== 1 && $length !== 1.5 && $length !== 2) {
            $length = 1;
        }
        $this->stopbits = $length;

It seems like $length can also be of type integer. However, the property $stopbits is declared as type double. Maybe add an additional type check?

        $this->formatedStopBits = $this->zStopBits($length);
        return true;
    }
    
    /**
     * Return stop bits set
     * 
     * @return float
     */
    public function getStopBits()
    {
        return $this->stopbits;
    }
    
    /**
     * Format stop bit command
     * 
     * @param float $length
     * @return string
     */
    public function zStopBits($length)
    {
        $stopb = (($length == 1) ? "-" : "") . "cstopb";
        if ($this->ostype === self::OS_WIN) {
            $stopb = "STOP=" . $length;
        }
        return $stopb;
    }
    
    /**
     * Set the flow control mode.
     * Availible modes :
     *   "none" : no flow control
     *   "rts/cts" : use RTS/CTS handshaking
     *   "xon/xoff" : use XON/XOFF protocol
     * 
     * @param string $flow
     * @return boolean
     */
    public function setFlowControl($flow)
    {
        switch ($flow) {
            case 'rts/cts':
                $this->flowcontrol = self::FLOW_RTSCTS;
                break;
            case 'xon/xoff':
                $this->flowcontrol = self::FLOW_XONXOFF;
                break;
            default:
                $this->flowcontrol = self::FLOW_NONE;
        }
        $this->formatedFlowControl = $this->zFlowControl($this->flowcontrol);
        return true;
    }
    
    /**
     * Returns flow control set
     * 
     * @return string
     */
    public function getFlowControl()
    {
        switch ($this->flowcontrol) {
            case 0:
                return 'none';
            case 1:
                return 'rts/cts';
            case 2:
                return 'xon/xoff';
        }
    }
    
    /**
     * Return flow control command formated for OP type
     * 
     * @param int $flow
     * @return string
     */
    protected function zFlowControl($flow)
    {
        $modeos = [
            //windows
            self::OS_WIN => ["xon=off octs=off rts=on","xon=off octs=on rts=hs","xon=on octs=off rts=on"],
            //linux
            self::OS_LINUX => ["clocal -crtscts -ixon -ixoff","-clocal crtscts -ixon -ixoff","-clocal -crtscts ixon ixoff"],
            //cygwin
            self::OS_CYGWIN => ["clocal -crtscts -ixon -ixoff","-clocal crtscts -ixon -ixoff","-clocal -crtscts ixon ixoff"],
            //unix
            self::OS_UNIX => ["clocal -crtscts -ixon -ixoff","-clocal crtscts -ixon -ixoff","-clocal -crtscts ixon ixoff"],
            //bsd
            self::OS_BSD => ["clocal -crtscts -ixon -ixoff","-clocal crtscts -ixon -ixoff","-clocal -crtscts ixon ixoff"],
            //macos
            self::OS_OSX => ["clocal -crtscts -ixon -ixoff","-clocal crtscts -ixon -ixoff","-clocal -crtscts ixon ixoff"],
            //hpux
            self::OS_HPUX => ["clocal -crtscts -ixon -ixoff","-clocal crtscts -ixon -ixoff","-clocal -crtscts ixon ixoff"]
        ];
        return (string) $modeos[$this->ostype][$flow];
    }
    
    /**
     * Find OS type
     * 
     * @return int
     */
    protected function getOs()
    {
        switch (true) {

It seems like you are loosely comparing stristr(PHP_OS, 'DAR') of type string to the boolean true. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

It seems like you are loosely comparing stristr(PHP_OS, 'WIN') of type string to the boolean true. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

It seems like you are loosely comparing stristr(PHP_OS, 'LINUX') of type string to the boolean true. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

It seems like you are loosely comparing stristr(PHP_OS, 'CYGWIN') of type string to the boolean true. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

It seems like you are loosely comparing stristr(PHP_OS, 'HPUX') of type string to the boolean true. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

It seems like you are loosely comparing stristr(PHP_OS, 'BSD') of type string to the boolean true. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

It seems like you are loosely comparing stristr(PHP_OS, 'UNIX') of type string to the boolean true. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

            case stristr(PHP_OS, 'DAR'):
                return self::OS_OSX;
            case stristr(PHP_OS, 'WIN'):
                return self::OS_WIN;
            case stristr(PHP_OS, 'LINUX'):
                return self::OS_LINUX;
            case stristr(PHP_OS, 'CYGWIN'):
                return self::OS_CYGWIN;
            case stristr(PHP_OS, 'HPUX'):
                return self::OS_HPUX;
            case stristr(PHP_OS, 'BSD'):
                return self::OS_BSD;
            case stristr(PHP_OS, 'UNIX'):
                return self::OS_UNIX;
            default:
                return self::OS_UNKNOWN;
        }
    }
    
    /**
     * Exec command line in OS console
     * 
     * @param type $cmd
     * @param type $out
     * @return type
     */
    protected function execCommand($cmd, &$out = null)
    {
        $desc = array(
            1 => array("pipe", "w"),
            2 => array("pipe", "w")
        );
        $proc = proc_open($cmd, $desc, $pipes);
        $ret = stream_get_contents($pipes[1]);
        $err = stream_get_contents($pipes[2]);
        fclose($pipes[1]);
        fclose($pipes[2]);
        $retVal = proc_close($proc);
        if (func_num_args() == 2) {
            $out = array($ret, $err);
        }
        return $retVal;
    }
}