塔吊/塔机数据监控
设备对接 2019-04-04 09:29:46

 1、模拟发送通信命令，创建client文件，通过cli跑文件：

PHP Code复制内容到剪贴板
  1. $client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);  
  2. $client->on("connect", function($cli) {  
  3.     echo "连接成功，开始发送数据：\r\n";  
  4.     $d = 'a55a3101010671714ac9130403102a2b01f40000000013380bb8a4000000000000020000000000000000010056cc33c33c';  
  5.     $data = pack("H*",$d);  
  6.   
  7.     $cli->send($data);  
  8. });  
  9. $client->on("receive", function($cli, $data){  
  10.     echo "received: {$data}\n";  
  11. });  
  12. $client->on("error", function($cli){  
  13.     echo "connect failed\n";  
  14. });  
  15. $client->on("close", function($cli){  
  16.     echo "connection close\n";  
  17. });  
  18. $client->connect("0.0.0.0", 9512, 0.5);  

 

2、建立tcp服务器，通过9502端口接收数据：

PHP Code复制内容到剪贴板
  1. <?php  
  2. define('TCP_PORT', '9502');//tcp端口号  
  3.   
  4. define('MYSQL_HOST', 'mysql');  
  5. define('MYSQL_PORT', 3306);  
  6. define('MYSQL_USER', 'root');  
  7. define('MYSQL_PASSWORD', '123456,');  
  8. define('MYSQL_DATABASE', 'test');  
  9. define('MYSQL_TABLE_PREFIX', 'yoyocmf_');  // 数据库前缀  
  10.   
  11. define('PID_FILE', '/var/www/html/logs/9502.pid');// 线程ID  
  12. define('LOG_FILE', '/var/www/html/logs/9502.log');// 日志地址  
  13.   
  14. class TcpServer  
  15. {  
  16.     public $server;  
  17.   
  18.     public function __construct()  
  19.     {  
  20.         $serv = new swoole_server("0.0.0.0", TCP_PORT);  
  21.   
  22.         $serv->set([  
  23.             'daemonize' => true,      // 设置守护进程模式  
  24.             'log_file' => LOG_FILE,  
  25.             'task_worker_num' => 4, // 4个task  
  26. //            'open_eof_split' => true, //打开EOF_SPLIT检测  
  27. //            'package_eof' => "\r\n", //设置EOF，onReceive每次仅收到一个以EOF字串结尾的数据包  
  28.             'max_request' => 1000, // 防止 PHP 内存溢出, 一个工作进程处理 X 次任务后自动重启 (注: 0,不自动重启)用于worker进程  
  29.             'task_max_request' => 1000, // 防止 PHP 内存溢出  
  30.             'pid_file' => PID_FILE, // 这里可以使用一键重启环境  
  31.         ]);  
  32.   
  33.         $serv->on('connect', [$this, 'onConnect']);  
  34.   
  35.         //监听数据接收事件  
  36.         $serv->on('receive', [$this, 'onReceive']);  
  37.   
  38.         $serv->on('WorkerStart', [$this, 'onWorkerStart']);  
  39.         $serv->on('task', [$this, 'onTask']);  
  40.         $serv->on('finish', [$this, 'onFinish']);  
  41.   
  42.         $serv->on('close', [$this, 'onClose']);  
  43.         $this->server = $serv;  
  44.   
  45.         $serv->start();  
  46.     }  
  47.   
  48.     public function onConnect($server, $fd)  
  49.     {  
  50.         echo "Client: Connect.\n"; // 连接成功  
  51.     }  
  52.   
  53.     /** 
  54.      * worker中 用到的时候就用协程mysql就行 
  55.      * @param $server 
  56.      * @param $worker_id 
  57.      */  
  58.     public function onWorkerStart($server, $worker_id)  
  59.     {  
  60.         if ($server->taskworker === true) {  
  61.             echo date('Y-m-d H:i:s') . " task : " . $worker_id . " start" . PHP_EOL;  
  62.         } else {  
  63.             echo date('Y-m-d H:i:s') . " worker : " . $worker_id . " start" . PHP_EOL;  
  64.         }  
  65.     }  
  66.   
  67.     public function onReceive($serv, $fd, $from_id, $data)  
  68.     {  
  69. //        echo date("Y-m-d H:i:s") . "转换后数据 => " . bin2hex($data) . "\n\n\n";  
  70. //        // 转换塔吊发过来的命令字符串  
  71. //        $commandStr = bin2hex($data);  
  72. // 转换塔吊命令为数组，一个字节，代表一个数组，第几个字节，就是第几个数组，如果其他硬件，注意unpack都是正数，如果有负数，要看文档，比如温度等  
  73.         $commandPack = unpack("C*", $data);  
  74.         /** 
  75.          * TODO 判断帧头是否为0xA55A 
  76.          * 帧头是两个字节,三套解决方案 
  77.          * 一、 截取十六进制字符串前四个字符串，判断是否为a55a （substr($commandStr, 0, 4)） 
  78.          * 二、 判断 数组[1] == 0xa5 && 数组[2] == 0x5a 
  79.          * 三、 判断 (数组[1] << 8) + 数组[2]  = （0xa55a的十进制数值） (本次用第三套) 
  80.          *     如果是三个字节：arr[1] << (8*2) 加  arr[2] << 8 加  arr[3] 
  81.          *     如果是四个字节：arr[1] << (8*3) 加  arr[2] << (8*2) 加 arr[3] << 8 加 arr[4] 
  82.          *     以上是大端的方法，即高字节在前，低字节在后（一般协议都是这种） 
  83.          *     小端反过来，低字前在前，高字节在后 
  84.          */  
  85.         $commandHead = ($commandPack[1] << 8) + $commandPack[2]; //帧头是2字节，获取帧头的十进制值  
  86.   
  87.         if ($commandHead == 0xA55A) {  
  88.   
  89.             $serv->task([  
  90.                 "commandStr" => bin2hex($data),  
  91.                 "commandPack" => $commandPack  
  92.             ]);  
  93.   
  94.         } else {  
  95.             echo "数据不合法，十进制帧头为：" . $commandHead . PHP_EOL;  
  96.             return false;  
  97.         }  
  98.         $serv->send($fd, "Server: Receiving completed \n");  
  99.     }  
  100.   
  101.   
  102.     /** 
  103.      * 任务处理 先写入redis数据，再判断数量写入mysql库 
  104.      * @param $server 
  105.      * @param $task_id 
  106.      * @param $from_id 
  107.      * @param $data 
  108.      * @return string 
  109.      */  
  110.     public function onTask($server, $task_id, $from_id, $data)  
  111.     {  
  112.         $commandStr = $data["commandStr"];  
  113.         $commandPack = $data["commandPack"];  
  114.         $res = $this->AnalyzePackage($commandStr, $commandPack);  
  115. //        echo $res["errmsg"] . "\n";  
  116.   
  117.         $server->finish("insert DB -> OK");  
  118.     }  
  119.   
  120.   
  121.     /** 
  122.      * 解析设备注册 / 设备参数上报 
  123.      * @param string $str 
  124.      * @param array $arr 
  125.      * @return array 
  126.      */  
  127.     function AnalyzePackage($str = "", $arr = array())  
  128.     {  
  129. //        echo date("Y-m-d H:i:s")."：" . $str . PHP_EOL;  
  130.         $res = [  
  131.             "errcode" => 1,  
  132.             "errmsg" => "未解析"  
  133.         ];  
  134. //        print_r($arr);  
  135.   
  136.         // 获取帧尾，固定八位为Cc33c33c  
  137.         $commandTail = substr($str, -8); //Cc33c33c  
  138.         if ($commandTail != "cc33c33c") {  
  139.             return [  
  140.                 "errcode" => 1,  
  141.                 "errmsg" => "上报数据命令有误" . $str  
  142.             ];  
  143.         }  
  144.         // 判断响应帧类型 来区分，注册和参数上报,整改在判断的时候，各种进制是通用的  
  145.         $commandResponse = $arr[6];  
  146.   
  147.         if ($commandResponse == 0x00) {  
  148.             // 设备注册请求  
  149.             $res = [  
  150.                 "errcode" => 0,  
  151.                 "errmsg" => "设备注册请求"  
  152.             ];  
  153.         } else if ($commandResponse == 0x01) {  
  154.             // 设备注册响应  
  155.             $res = [  
  156.                 "errcode" => 0,  
  157.                 "errmsg" => "设备注册响应"  
  158.             ];  
  159.   
  160.         } else if ($commandResponse == 0x02) {  
  161.             // 设备参数上报  
  162.             $res = [  
  163.                 "errcode" => 0,  
  164.                 "errmsg" => "设备参数上报"  
  165.             ];  
  166.         } else if ($commandResponse == 0x06) {  
  167.             // 实时数据上报  
  168.             $res = [  
  169.                 "errcode" => 0,  
  170.                 "errmsg" => "实时数据上报"  
  171.             ];  
  172.   
  173.             // 7.8.9.10 是设备编号  
  174.             $code = [  
  175.                 $arr[7],  
  176.                 $arr[8],  
  177.                 $arr[9],  
  178.                 $arr[10]  
  179.             ];  
  180.             // 设备编号，6-10帧位  
  181.             $deviceCode = $this->getDecimalSumInt($code); // 这个是十进制数字，将指定帧数的值相加  
  182.   
  183.             $sendYear = $arr[11] + 2000; //年,年为2000+  
  184.             $sendMonth = $arr[12];//月  
  185.             $sendDay = $arr[13];  //日  
  186.             $sendHour = $arr[14]; //时  
  187.             $sendMin = $arr[15];  //分  
  188.             $sendSec = $arr[16];  //秒  
  189.   
  190.             // 上传时间，年月日时分秒  
  191.             $sendTime = $sendYear . "-" . $sendMonth . "-" . $sendDay . " " . $sendHour . ":" . $sendMin . ":" . $sendSec;  
  192.   
  193.             // 高度（单位：米）  
  194.             // ($arr[17] << 8) + $arr[18]  
  195.             // $arr[17] * 256 + $arr[18]  
  196.             $gd = $this->getDecimalSumInt([$arr[17],$arr[18]]);//$arr[17] * 256 + $arr[18] 也可以  
  197.   
  198.             // 幅度（单位：米）  
  199.             $fd = $this->getDecimalSumInt([$arr[19],$arr[20]]);  
  200.             // 回转（单位：度）  
  201.             $rotate = $this->getDecimalSumInt([$arr[21],$arr[22]]);  
  202.             // 载重（单位：KG）  
  203.             $load = $this->getDecimalSumInt([$arr[23],$arr[24]]);  
  204.             // 当前允许载重（单位：KG）  
  205.             $loadAllow = $this->getDecimalSumInt([$arr[25],$arr[26]]);  
  206.             // 载重百分比（单位：百分点）  
  207.             $loadPercentage = $arr[27];  
  208.             // 风速（单位：米/秒）  
  209.             $windSpeed = $this->getDecimalSumInt([$arr[28],$arr[29]]);  
  210.             // 倾斜（单位：度）  
  211.             $tilt = $this->getDecimalSumInt([$arr[30],$arr[31]]);  
  212.             // 高度限位值 报警  
  213.             $heightLimit = $arr[32];  
  214.             $gdWarn = $heightLimit & 0x0f;  // 获取高度限位值 低四位,00正常 01预警  02报警  
  215.             $heightHighFour = ($heightLimit & 0xf0) >> 4; // 获取高度限位值 高四位  
  216.   
  217.             // 幅度回转限位 报警  
  218.             $widthLimit = $arr[33];  
  219.             $fdNWarn = $widthLimit & 0x0f;        // 获取幅度回转限位值 低四位，低4bit：00正常 01近端限位预警 02近端限位报警  
  220.             $fdZWarn = ($widthLimit & 0xf0) >> 4; // 获取幅度回转限位值 高四位，高4bit：00正常 01左限位预警 02左限位报警 03右限位预警 04右限位报警  
  221.   
  222.             // 载重限制值 报警  
  223.             $loadWarn = $arr[34];  
  224.   
  225.             // 倾斜风速限制 报警  
  226.             $tiltLimit = $arr[35];  
  227.             $tiltFsWarn = $tiltLimit & 0x0f;        // 获取倾斜风速限制 低四位，00风速正常 01风速预警 02风速报警  
  228.             $tiltQxWarn = ($tiltLimit & 0xf0) >> 4; // 获取倾斜风速限制 高四位，00倾斜正常  01倾斜预警  02倾斜报警  
  229.   
  230.             // 干涉上下限位 报警  
  231.             $topBottomLimit = $arr[36];  
  232.             $topWarn = $topBottomLimit & 0x0f;           // 干涉上下限位 低四位，00上限位正常  01上限位预警  02上限位报警  
  233.             $bottomWarn = ($topBottomLimit & 0xf0) >> 4; // 干涉上下限位 高四位，00下限位正常  01下限位预警  02下限位报警  
  234.   
  235.             // 干涉前后限位 报警  
  236.             $frontBackendLimit = $arr[37];  
  237.             $frontWarn = $frontBackendLimit & 0x0f;       // 干涉前后限位 低四位，00前限位正常  01前限位预警  02前限位报警  
  238.             $backWarn = ($frontBackendLimit & 0xf0) >> 4; // 干涉前后限位 高四位，00后限位正常  01后限位预警  02后限位报警  
  239.   
  240.             // 干涉左右限位 报警  
  241.             $leftRightLimit = $arr[38];  
  242.             $leftWarn = $leftRightLimit & 0x0f;          // 干涉左右限位 低四位，00左限位正常  01左限位预警  02左限位报警  
  243.             $rightWarn = ($leftRightLimit & 0xf0) >> 4;  // 干涉左右限位 高四位，00右限位正常  01右限位预警  02右限位报警  
  244.   
  245.             // 碰撞上下限位 报警  
  246.             $CollideTopBottomLimit = $arr[39];  
  247.             $CollideTopWarn = $CollideTopBottomLimit & 0x0f;           // 碰撞上下限位 低四位，00上限位正常  01上限位预警  02上限位报警  
  248.             $CollideBottomWarn = ($CollideTopBottomLimit & 0xf0) >> 4; // 碰撞上下限位 高四位，00下限位正常  01下限位预警  02下限位报警  
  249.   
  250.             // 碰撞前后限位 报警  
  251.             $CollideFrontBackendLimit = $arr[40];  
  252.             $CollideFrontWarn = $CollideFrontBackendLimit & 0x0f;          // 碰撞前后限位 低四位，00前限位正常  01前限位预警  02前限位报警  
  253.             $CollideBackendWarn = ($CollideFrontBackendLimit & 0xf0) >> 4; // 干涉前后限位 高四位，00后限位正常  01后限位预警  02后限位报警  
  254.   
  255.             // 碰撞左右限位 报警  
  256.             $CollideLeftRightLimit = $arr[41];  
  257.             $CollideLeftWarn = $CollideLeftRightLimit & 0x0f;          // 干涉左右限位 低四位，00左限位正常  01左限位预警  02左限位报警  
  258.             $CollideRightWarn = ($CollideLeftRightLimit & 0xf0) >> 4;  // 干涉左右限位 高四位，00右限位正常  01右限位预警  02右限位报警  
  259.   
  260.             // 继电器状态  
  261.             $jdq = $arr[42];  
  262.             $jdqStatus = $this->getBitByByte($jdq); //只取六个，分别属于：上下前后左右  
  263. //            [  
  264. //                0 => 0,  
  265. //                1 => 0,  
  266. //                2 => 0,  
  267. //                3 => 0,  
  268. //                4 => 0,  
  269. //                5 => 0,  
  270. //                6 => 0,  
  271. //                7 => 0  
  272. //            ];  
  273.   
  274.             $workStatus = $arr[43];  
  275.             // 传感器状态  
  276.             $cgq = $arr[44];  
  277.             $cgqStatus = $this->getBitByByte($cgq); //只取六个，分别属于：高度/幅度/回转/重量/风速/倾斜  
  278.   
  279.             $created_at = time();  
  280.             $insert = [  
  281.                 "code" => $deviceCode,  
  282.                 "gd" => $gd / 10, //单位 0.1米  
  283.                 "fd" => $fd / 10, //单位 0.1米  
  284.                 "rotate" => $rotate / 10, //单位 0.1米  
  285.                 "load" => $load,  
  286.                 "load_allow" => $loadAllow,  
  287.                 "load_percentage" => $loadPercentage,  
  288.                 "wind_speed" => $windSpeed / 10, //单位 0.1米/秒  
  289.                 "tilt" => $tilt / 100, // 单位 0.01度  
  290.                 "receive_time" => $sendTime,  
  291.                 "created_at" => $created_at,  
  292.                 "year" => date("Y", $created_at),  
  293.                 "month" => date("m", $created_at),  
  294.                 "day" => date("d", $created_at),  
  295.                 "gd_warn" => $gdWarn,  
  296.                 "fd_warn" => $fdNWarn . "|" . $fdZWarn,  
  297.                 "load_warn" => $loadWarn,  
  298.                 "tilt_warn" => $tiltFsWarn . "|" . $tiltQxWarn,  
  299.                 "top_bottom_warn" => $topWarn . "|" . $bottomWarn,  
  300.                 "front_backend_warn" => $frontWarn . "|" . $backWarn,  
  301.                 "left_right_warn" => $leftWarn . "|" . $rightWarn,  
  302.                 "collide_top_bottom_warn" => $CollideTopWarn . "|" . $CollideBottomWarn,  
  303.                 "collide_front_backend_warn" => $CollideFrontWarn . "|" . $CollideBackendWarn,  
  304.                 "collide_left_right_warn" => $CollideLeftWarn . "|" . $CollideRightWarn,  
  305.                 "jdq" => $jdqStatus[0] . "|" . $jdqStatus[1] . "|" . $jdqStatus[2] . "|" . $jdqStatus[3] . "|" . $jdqStatus[4] . "|" . $jdqStatus[5],  
  306.                 "work_status" => $workStatus,  
  307.                 "cgq" => $cgqStatus[0] . "|" . $cgqStatus[1] . "|" . $cgqStatus[2] . "|" . $cgqStatus[3] . "|" . $cgqStatus[4] . "|" . $cgqStatus[5],  
  308.                 "ydata" => $str  
  309.             ];  
  310.   
  311.             go(function () use ($insert) {  
  312.                 $tablename = MYSQL_TABLE_PREFIX . "monitor_tower_data";// 环境监测数据表名  
  313.                 $swoole_mysql = new Swoole\Coroutine\MySQL();  
  314.                 $swoole_mysql->connect([  
  315.                     'host' => MYSQL_HOST,  
  316.                     'port' => MYSQL_PORT,  
  317.                     'user' => MYSQL_USER,  
  318.                     'password' => MYSQL_PASSWORD,  
  319.                     'database' => MYSQL_DATABASE,  
  320.                 ]);  
  321.   
  322.                 $field = "";  
  323.                 $value = "";  
  324.                 foreach ($insert as $k => $v) {  
  325.                     $field .= "`$k`,";  
  326.                     $value .= "'$v',";  
  327.                 }  
  328.                 $field = rtrim($field, ',');  
  329.                 $value = rtrim($value, ',');  
  330.                 $sql = "INSERT INTO {$tablename} (".$field.") VALUES (".$value.")";  
  331. //                echo $sql . "\n";  
  332.                 $ret = $swoole_mysql->query($sql);  
  333. //                var_dump($ret);  
  334.             });  
  335.   
  336. //            echo "设备编号：" . $deviceCode . "\n";  
  337. //            echo "上传时间：" . $sendTime . "\n";  
  338. //            echo "高度：" . $gd . "米\n";  
  339. //            echo "幅度：" . $fd . "米\n";  
  340. //            echo "回转：" . $rotate . "度\n";  
  341. //            echo "载重：" . $load . "KG\n";  
  342. //            echo "当前允许载重：" . $loadAllow . "KG\n";  
  343. //            echo "载重百分比：" . $loadPercentage . "%\n";  
  344. //            echo "风速：" . $windSpeed . "米/秒\n";  
  345. //            echo "倾斜：" . $tilt . "度\n";  
  346. //  
  347. //            if ($gdWarn == 1) {  
  348. //                echo "高度限位预警：" . "预警" . "\n";  
  349. //            } else if ($gdWarn == 2) {  
  350. //                echo "高度限位预警：" . "报警" . "\n";  
  351. //            } else {  
  352. //                echo "高度限位预警：" . "正常" . "\n";  
  353. //            }  
  354. //  
  355. //            if ($fdZWarn == 1) {  
  356. //                echo "幅度回转限位：" . "左限位预警" . "\n";  
  357. //            } else if ($fdZWarn == 2) {  
  358. //                echo "幅度回转限位：" . "左限位报警" . "\n";  
  359. //            } else if ($fdZWarn == 3) {  
  360. //                echo "幅度回转限位：" . "右限位预警" . "\n";  
  361. //            } else if ($fdZWarn == 4) {  
  362. //                echo "幅度回转限位：" . "右限位报警" . "\n";  
  363. //            } else {  
  364. ////            echo "幅度回转限位：" . "正常" . "\n";  
  365. //            }  
  366. //  
  367. //            if ($fdNWarn == 1) {  
  368. //                echo "幅度回转限位：" . "近端限位预警" . "\n";  
  369. //            } else if ($fdNWarn == 2) {  
  370. //                echo "幅度回转限位：" . "近端限位报警" . "\n";  
  371. //            } else if ($fdNWarn == 3) {  
  372. //                echo "幅度回转限位：" . "远端限位预警" . "\n";  
  373. //            } else if ($fdNWarn == 4) {  
  374. //                echo "幅度回转限位：" . "远端限位报警" . "\n";  
  375. //            } else {  
  376. ////            echo "幅度回转限位：" . "正常" . "\n";  
  377. //            }  
  378. //  
  379. //            if ($loadWarn == 1) {  
  380. //                echo "载重限制：" . "载重预警" . "\n";  
  381. //            } else if ($loadWarn == 2) {  
  382. //                echo "载重限制：" . "载重报警" . "\n";  
  383. //            } else if ($loadWarn == 3) {  
  384. //                echo "载重限制：" . "违章" . "\n";  
  385. //            } else {  
  386. //                echo "载重限制：" . "正常" . "\n";  
  387. //            }  
  388. //  
  389. //            if ($tiltFsWarn == 1) {  
  390. //                echo "风速限制：" . "风速预警" . "\n";  
  391. //            } else if ($tiltFsWarn == 2) {  
  392. //                echo "风速限制：" . "风速报警" . "\n";  
  393. //            } else {  
  394. //                echo "风速限制：" . "风速正常" . "\n";  
  395. //            }  
  396. //  
  397. //            if ($tiltQxWarn == 1) {  
  398. //                echo "倾斜限制：" . "倾斜预警" . "\n";  
  399. //            } else if ($tiltQxWarn == 2) {  
  400. //                echo "倾斜限制：" . "倾斜报警" . "\n";  
  401. //            } else {  
  402. //                echo "倾斜限制：" . "倾斜正常" . "\n";  
  403. //            }  
  404. //  
  405. //            if ($topWarn == 1) {  
  406. //                echo "上限位预警" . "\n";  
  407. //            } else if ($topWarn == 2) {  
  408. //                echo "上限位报警" . "\n";  
  409. //            } else {  
  410. //                echo "上限位正常" . "\n";  
  411. //            }  
  412. //  
  413. //            if ($bottomWarn == 1) {  
  414. //                echo "下限位预警" . "\n";  
  415. //            } else if ($bottomWarn == 2) {  
  416. //                echo "下限位报警" . "\n";  
  417. //            } else {  
  418. //                echo "下限位正常" . "\n";  
  419. //            }  
  420. //  
  421. //            if ($frontWarn == 1) {  
  422. //                echo "前限位预警" . "\n";  
  423. //            } else if ($frontWarn == 2) {  
  424. //                echo "前限位报警" . "\n";  
  425. //            } else {  
  426. //                echo "前限位正常" . "\n";  
  427. //            }  
  428. //  
  429. //            if ($backWarn == 1) {  
  430. //                echo "后限位预警" . "\n";  
  431. //            } else if ($backWarn == 2) {  
  432. //                echo "后限位报警" . "\n";  
  433. //            } else {  
  434. //                echo "后限位正常" . "\n";  
  435. //            }  
  436. //  
  437. //            if ($leftWarn == 1) {  
  438. //                echo "左限位预警" . "\n";  
  439. //            } else if ($leftWarn == 2) {  
  440. //                echo "左限位报警" . "\n";  
  441. //            } else {  
  442. //                echo "左限位正常" . "\n";  
  443. //            }  
  444. //  
  445. //            if ($rightWarn == 1) {  
  446. //                echo "右限位预警" . "\n";  
  447. //            } else if ($rightWarn == 2) {  
  448. //                echo "右限位报警" . "\n";  
  449. //            } else {  
  450. //                echo "右限位正常" . "\n";  
  451. //            }  
  452. //  
  453. //            if ($CollideTopWarn == 1) {  
  454. //                echo "碰撞上限位预警" . "\n";  
  455. //            } else if ($CollideTopWarn == 2) {  
  456. //                echo "碰撞上限位报警" . "\n";  
  457. //            } else {  
  458. //                echo "碰撞上限位正常" . "\n";  
  459. //            }  
  460. //  
  461. //            if ($CollideBottomWarn == 1) {  
  462. //                echo "碰撞下限位预警" . "\n";  
  463. //            } else if ($CollideBottomWarn == 2) {  
  464. //                echo "碰撞下限位报警" . "\n";  
  465. //            } else {  
  466. //                echo "碰撞下限位正常" . "\n";  
  467. //            }  
  468. //  
  469. //            if ($CollideFrontWarn == 1) {  
  470. //                echo "碰撞前限位预警" . "\n";  
  471. //            } else if ($CollideFrontWarn == 2) {  
  472. //                echo "碰撞前限位报警" . "\n";  
  473. //            } else {  
  474. //                echo "碰撞前限位正常" . "\n";  
  475. //            }  
  476. //  
  477. //            if ($CollideBackendWarn == 1) {  
  478. //                echo "碰撞后限位预警" . "\n";  
  479. //            } else if ($CollideBackendWarn == 2) {  
  480. //                echo "碰撞后限位报警" . "\n";  
  481. //            } else {  
  482. //                echo "碰撞后限位正常" . "\n";  
  483. //            }  
  484. //  
  485. //            if ($CollideLeftWarn == 1) {  
  486. //                echo "碰撞左限位预警" . "\n";  
  487. //            } else if ($CollideLeftWarn == 2) {  
  488. //                echo "碰撞左限位报警" . "\n";  
  489. //            } else {  
  490. //                echo "碰撞左限位正常" . "\n";  
  491. //            }  
  492. //  
  493. //            if ($CollideRightWarn == 1) {  
  494. //                echo "碰撞右限位预警" . "\n";  
  495. //            } else if ($CollideRightWarn == 2) {  
  496. //                echo "碰撞右限位报警" . "\n";  
  497. //            } else {  
  498. //                echo "碰撞右限位正常" . "\n";  
  499. //            }  
  500. //            exit();  
  501.         }  
  502.   
  503.         return $res;  
  504.     }  
  505.   
  506.   
  507.     /** 
  508.      * 指定数组，或运算 返回int值 / 【int结果之间判断对等，不分进制】 
  509.      * 如果是三个字节：arr[1] << (8*2) 加  arr[2] << 8 加  arr[3] 
  510.      * 如果是四个字节：arr[1] << (8*3) 加  arr[2] << (8*2) 加 arr[3] << 8 加 arr[4] 
  511.      *     以上是大端的方法，即高字节在前，低字节在后（一般协议都是这种） 
  512.      *     小端反过来，低字前在前，高字节在后 
  513.      * @param array $arr 
  514.      * @return int 
  515.      */  
  516.     function getDecimalSumInt($arr = array())  
  517.     {  
  518.         $sum = 0;  
  519.         $count = count($arr);  
  520.         foreach ($arr as $k => $v) {  
  521.             $no = $count - ($k + 1);  
  522.             $sum |= $v << (8 * $no); // 或运算，和 += 一样的结果  
  523.         }  
  524. //    // 打印公式  
  525. //    for ($i = 0; $i < $count; $i++) {  
  526. //        $no = $count - ($i + 1);  
  527. //        if ($no > 0) {  
  528. //            $sum .= "$arr[$i] << (8 * " . ($count - ($i + 1)) . ") + ";  
  529. //        } else {  
  530. //            $sum .= "$arr[$i]";  
  531. //        }  
  532. //    }  
  533.         return $sum;  
  534.     }  
  535.   
  536.     /** 
  537.      * 根据字节返回每一位 
  538.      * @param int $byte 
  539.      * @return array 
  540.      */  
  541.     function getBitByByte($byte = 0)  
  542.     {  
  543.         $res = [];  
  544.         for ($i = 7; $i >= 0; $i--) {  
  545. //        $res[$i] = ($byte & 1); //小端，从左到右  
  546.             $res[] = ($byte & 1); // 大端，从右到左  
  547.             $byte = ($byte >> 1);  
  548.         }  
  549.         return $res;  
  550.     }  
  551.   
  552.     /** 
  553.      * tcp服务器关闭 
  554.      * @param $ser 
  555.      * @param $fd 
  556.      */  
  557.     public function onClose($ser, $fd)  
  558.     {  
  559.         echo "client {$fd} closed\n";  
  560.     }  
  561.   
  562.     public function onFinish($server, $task_id, $data)  
  563.     {  
  564. //        echo "AsyncTask[$task_id] finished: {$data}\n";  
  565.     }  
  566.   
  567.   
  568. }  
  569.   
  570. // new TcpServer();  
  571.   
  572. if (!isset($argv[1])) {  
  573.     $argv[1] = 'restart';  
  574. }  
  575. if ($argv[1] == 'start') {  
  576.     echo "server start at " . date('Y-m-d H:i:s') . "\n";  
  577.     new TcpServer();  
  578. } elseif ($argv[1] == 'stop') {  
  579.     if (file_exists(PID_FILE) && swoole_process::kill(file_get_contents(PID_FILE), 0)) {  
  580.         swoole_process::kill(file_get_contents(PID_FILE), SIGTERM);  
  581.         if (file_exists(PID_FILE)) {  
  582.             unlink(PID_FILE);  
  583.         }  
  584.         echo "server stop at " . date('Y-m-d H:i:s') . "\n";  
  585.     } else {  
  586.         echo "server not exist" . "\n";  
  587.     }  
  588. } elseif ($argv[1] == 'restart') {  
  589.     if (file_exists(PID_FILE) && swoole_process::kill(file_get_contents(PID_FILE), 0)) {  
  590.         $pid = file_get_contents(PID_FILE);  
  591.         swoole_process::kill($pid, SIGTERM);  
  592.         while (true) {  
  593.             if (!swoole_process::kill($pid, 0)) {  
  594.                 break;  
  595.             }  
  596.             usleep(100000);  
  597.         }  
  598.         if (file_exists(PID_FILE)) {  
  599.             unlink(PID_FILE);  
  600.         }  
  601.         echo "server restart at " . date('Y-m-d H:i:s') . "\n";  
  602.         new TcpServer();  
  603.     } else {  
  604.         echo "server start at " . date('Y-m-d H:i:s') . "\n";  
  605.         new TcpServer();  
  606.     }  
  607. }  

 

 

启动TCP Server：

php server9512.php start 启动

php server9512.php stop 停止

php server9512.php restart 平滑重启

 

 

 

本文来自于：http://www.yoyo88.cn/note/device/417.html

上一篇 海康视频监控对接
下一篇 高支模协议对接
相关的文章
Powered by yoyo苏ICP备15045725号