通过SSH免密提交代码到github，屡用不爽啊，本人很喜欢。

本人两个github账号count A和count B，分别记录不同的东西，先前一台电脑上只使用一个账号 count A，并没有发现什么问题。

问题：

但是最近准备也同时在本电脑上使用另一个count B账号，在添加公钥到github时，提示"Key is already in use"，原因是这个电脑上的公钥已经配置到count A了， 而github是不允许一个公钥同时添加到多个账户的，不然github服务器检测到有多个公钥和你的私钥匹配，你的每次提交岂不是要被提交到多个账号或错误账号对应的仓库中了（Oh My God，老板很生气，后果很严重）

查了网上基本上都是如下两种相关方案

1，删除count A中配置的公钥，这样就可以将公钥留出来配置到count B中（这个遇到与我一样的问题，但是删除了count A中的公钥，我以后还如何往count A中提交代码，总不能删来删去，加来加去吧）

2，另一种是git多账号配置，但是点进去一看，大多是为不同的仓库托管平台github、gitlab、gitee进行配置， 提交代码到这些不同平台的仓库（此种与其说是多账号，倒不如说是多平台配置嘛，且同时在这不同的平台上使用同一把公钥也是允许的，更不会报"Key is already in use", 些方案也解决不了我的问题）

那么有没有一种方案够满足在同一台电脑上同时使用不同类型的git代码托管平台、同一平台下不同的账号呢？

答案：没有..........不可能，自然是有的了，以下进入最正点的解决方案部分：

解决方案：

首先为了便于密钥的个性化管理，在本机用户的.ssh下为不同平台和不同用户创建不同的密钥文件夹：

1，github-552277（该文件夹用来保存github上的用户名为552277账号密钥

2，github-dailyplanner(该文件夹用来保存github上用户名为dailyplanner账号密钥）

3，gitee-dailyplanner(该文件夹用来保存gitee上用户名为dailyplanner账号密钥)

并分别在各个文件夹下按如下方式生成一对密钥：

并分别在各个文件夹下按如下方式生成一对密钥：

$ ssh-keygen -t rsa -C "15090552277@163.com"
Generating public/private rsa key pair.
Enter file in which to save the key (/c/Users/weichangzhong/.ssh/id_rsa): /c/Users/weichangzhong/.ssh/github-552277/id_rsa
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /c/Users/weichangzhong/.ssh/github-552277/id_rsa.
Your public key has been saved in /c/Users/weichangzhong/.ssh/github-552277/id_rsa.pub.
The key fingerprint is:
SHA256:PJuK5kRDsZRgOJGKdp5NJtUPvdwGnJUIxNefD0/Bj9I 15090552277@163.com
The key's randomart image is:
+---[RSA 3072]----+
|.+o.o.+o+ =.. .  |
|+. ..+ + B o   o |
|o.  +   = + ....o|
|o. + o . + o.+E..|
|. o O   S .  .=  |
|   + o   +     o |
|    .   o        |
|   ... .         |
|   oo .          |
+----[SHA256]-----+

然后在.ssh下创建ssh的无后缀名的配置文件config，使git命令执行时能够根据该文件的配置信息获取不同的密钥，

config:

Host github-552277.com
	HostName github.com
	PreferredAuthentications publickey
	IdentityFile ~/.ssh/github-552277/id_rsa
	User git

Host github-dailyplanner.com
	HostName github.com
	PreferredAuthentications publickey
	IdentityFile ~/.ssh/github-dailyplanner/id_rsa
	User git

Host gitee-dailyplanner.com
	HostName gitee.com
	PreferredAuthentications publickey
	IdentityFile ~/.ssh/gitee-dailyplanner/id_rsa
	User git

其中

1）Host后面的主机别名随意取，但是后续初始化本地跟踪远程项目的仓库时会用到

2）HostName后面的主机名，要和所要配置密钥的git托管平台的域名主体部分一致

3）IdentityFile 后面是相应平台密钥文件所在路径+密钥文件名称

注意： 同一个主机别名只能配置一个密钥，如果多个HOST 主机别名相同，则只有第一个生效。

最后使用各个密钥的流程如下：

1，向gitee 552277账号中新建的仓库github-527-rep提交代码：

正常的流程应该是如下

echo "# github-527-rep" >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin git@github.com:552277/github-527-rep.git
git push -u origin master

而我们变更了github的主机别名后，则需要将其中命令：

git remote add origin git@github.com:552277/github-527-rep.git

 变更为如下即可

git remote add origin git@github-552277.com:552277/github-527-rep.git

其中gitee-552277.com就是我们在.ssh/config中配置的别名，当我们执行如下命令时， git会自动识别为通过SSH协议连接远程仓库，并在用户的.ssh/config中找到名称为github-552277的配置信息：

Host github-552277.com
	HostName github.com
	PreferredAuthentications publickey
	IdentityFile ~/.ssh/github-552277/id_rsa
	User git

然后根据配置信息知道要从~/.ssh/github-552277/id_rsa文件中获取密钥，链接到github.com托管平台的服务，找到552277用户的github-527-rep仓库进行关联，并在本地当前项目隐藏目录.git/config下生成关联的远程仓库信息。

[core]
	repositoryformatversion = 0
	filemode = false
	bare = false
	logallrefupdates = true
	symlinks = false
	ignorecase = true
[remote "origin"]
	url = git@github-552277.com:552277/github-527-rep.git
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
	remote = origin
	merge = refs/heads/master

第一次执行带分支另名的命令后，以后每次执行与远程仓库相关的命令时，不必再在命令行中添加git远程仓库信息，每次都从配置文件中获取相应的 远程仓库信息和密钥，然后再进行连接并执行相关操作

注意，如果是克隆原来已有的分支到本地，也要将对应的克隆命令：

git clone git@github.com:552277/github-527-rep.git

 改为：

git clone git@github-552277.com:552277/github-527-rep.git

即凡是直接用到git@gitxxx.com:username/rep.git的，都要做相应的改动。

2，同理，如果第一次执行与github dailyplanner账号下的github-dailyplanner-rep仓库相关操作时，则只需要将其中

git@github.com:dailyplanner/github-dailyplanner-rep.git

 命令改为如下即可：

git@github-dailyplanner.com:dailyplanner/github-dailyplanner-rep.git

3，同理，如果第一次执行与gitee平台的dailyplanner账号下的gitee-daily-rep仓库相关操作时，则只需要将命令

git@gitee.com:dailyplanner/gitee-daily-rep.git

变更为如下即可

git@gitee-dailyplanner.com:dailyplanner/gitee-daily-rep.git

4，如果执行git@gitlab.com:dailyplanner/gitlab-dailyplanner-rep.git相关命令时............

           ......what ......竟然在.ssh/config中找不到相关配置了......

不过这时它才会使用默认的配置，就是使用.ssh/id_rsa密钥，连接到gitlab托管服务，找到dailyplanner用户的github-dailyplanner-rep仓库进行关联，并在本地当前项目隐藏目录.git/config下生成关联的远程仓库信息。

如上方案，即可实现在同一台电脑上使用同一个或不同的密钥连接不同的代码托管平台 或 使用不同的密钥连接同一类代码托管平台中的不同账号

OPC与三菱PLC通信
一、OPC软件配置
安装好KEPServerEX 6 软件，网上资源很多，自己下载。

打开软件：



我电脑上已经配置好了两个连接三菱Q03UDVPLC的通道，两个都可以同时连接，只需要设置不同的端口号就可以了。

再新建一个通道：

选择三菱网络通信



选择自己电脑的网口作为网络适配器



通道创建完成


点击添加设备，选择Q系列PLC：


ID设置，前面位网址，后面按照这样写就可以了，详细信息可以点击帮助了解。



选择TCP/IP，再设置端口号，PLC配置时需要添加此端口



设备创建完成


添加标记：



标记创建完成


二、PLC网络配置
设置IP地址



选择TCP，MC协议，设置端口号：



将参数下载到PLC，重启PLC。

三、通信测试
打开Quick Client



通信正常，同时另外两个通道也通信正常。




四、通过C#程序监控数据
需要一个OPCAutomation.dll文件，引入这个文件后就可以进行OPC通信编程。



代码如下：
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using OPCAutomation;//引入OPC命名空间
using System.Net;
using thinger.com.Models;

namespace OPC通信
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

        #region   创建对象

        private OPCServer KepServer;//OPC服务器对象
        private OPCBrowser KepBrower;//OPC服务器中的变量集
        private OPCGroups KepGroups;//OPC服务器中的组集合
        private OPCGroup KepGroup;//OPC服务器中组集合内的组
        private Array ServerHandles;//句柄
        private Array ServerErrors;//错误信息
        private int TransactionID = 0;
        private int CancelID = 0;

        #endregion

        #region  刷新节点列表
        /// <summary>
        /// 刷新节点列表
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnRefresh_Click(object sender, EventArgs e)
        {
            this.cbServerNode.Items.Clear();
            IPHostEntry iphost = Dns.GetHostEntry(Environment.MachineName);//获取计算机名
            if(iphost.AddressList.Length>0)
            {
                for(int i=0;i<iphost.AddressList.Length;i++)
                {
                    string host = Dns.GetHostEntry(iphost.AddressList[i]).HostName;//得到计算机名
                    if(!this.cbServerNode.Items.Contains(host))
                    {
                        this.cbServerNode.Items.Add(host);
                    }
                }
            }
            if(this.cbServerNode.Items.Count>0)
            {
                this.cbServerNode.SelectedIndex = 0;
            }
        }
        #endregion

        #region  获取服务列表
        private void cbServerNode_SelectedIndexChanged(object sender, EventArgs e)
        {
            KepServer = new OPCServer();
            object serverList = KepServer.GetOPCServers(this.cbServerNode.Text);//根据计算机名获取OPC服务器
            foreach (var item in (Array)serverList)
            {
                if (!this.cbServerName.Items.Contains(item))
                {
                    this.cbServerName.Items.Add(item);
                }
            }
            if (this.cbServerName.Items.Count > 0)
            {
                this.cbServerName.SelectedIndex = 0;
            }
        }
        #endregion

        #region   连接与断开
        /// <summary>
        /// 连接与断开
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnConnect_Click(object sender, EventArgs e)
        {
            if(this.btnConnect.Text=="Connect")
            {
                if(KepServer==null)
                {
                    KepServer = new OPCServer();
                }
                try
                {
                    KepServer.Connect(this.cbServerName.Text, this.cbServerNode.Text);//连接OPC
                }
                catch(Exception ex)
                {
                    MessageBox.Show("连接失败" + ex.Message);
                    return;
                }

                //获取所有的变量
                KepBrower = this.KepServer.CreateBrowser();
                KepBrower.ShowBranches();
                KepBrower.ShowLeafs(true);
                this.lvName.Items.Clear();

                //往lvName中添加变量名
                foreach(var item in KepBrower)
                {
                    this.lvName.Items.Add(item.ToString());
                }

                //通信组集合初始化
                KepGroups = KepServer.OPCGroups;
                KepGroups.DefaultGroupDeadband = 0;
                KepGroups.DefaultGroupIsActive = true;

                //通信组初始化
                KepGroup = KepGroups.Add("测试组");
                KepGroup.IsActive = true;//激活
                KepGroup.IsSubscribed = true;//订阅
                KepGroup.UpdateRate = 250;
                KepGroup.IsSubscribed = true;

                KepGroup.AsyncReadComplete += KepGroup_AsyncReadComplete;

                this.btnConnect.Text = "Disconnect";

                //开始读取
                this.timer1.Enabled = true;
            }
            else
            {
                KepServer.Disconnect();
                this.btnConnect.Text = "Connect";
                //停止读取
                this.timer1.Enabled = false;
            }
        }

        #endregion

        #region  双击创建变量
        //创建变量集合
        private List<OPCVariable> OPCVarList = new List<OPCVariable>();

        /// <summary>
        /// lvName双击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lvName_DoubleClick(object sender, EventArgs e)
        {
            if(this.lvName.SelectedItems!=null)
            {
                //添加一个变量到集合里
                OPCVarList.Add(new OPCVariable()
                {
                    OPCItemID = this.lvName.SelectedItems[0].Text   
                });

                //OPCVarList>>ServerHander

                //OPCVarList>>NumItems ItemIDS ClientHandles

                //Array和集合的区别 前者索引从1开始 后者索引从0开始

                List<string> ItemIDS = new List<string>();
                List<int> ClientHandles = new List<int>();

                //初始化
                ItemIDS.Add("0");
                ClientHandles.Add(0);

                //变量个数
                int Count = OPCVarList.Count;

                //循环添加
                for(int i=0;i<Count;i++)
                {
                    ItemIDS.Add(OPCVarList[i].OPCItemID);
                    ClientHandles.Add(i + 1);
                }

                Array ItemID = ItemIDS.ToArray();
                Array ClientHandle = ClientHandles.ToArray();

                KepGroup.OPCItems.AddItems(Count, ref ItemID, ref ClientHandle, out ServerHandles, out ServerErrors);
            }
        }
        #endregion

        #region 定时读取
        /// <summary>
        /// 定时读取事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void timer1_Tick(object sender, EventArgs e)
        {
            //读取变量  服务器 OPCServer->组集合 OPCGroups->组 OPCGroup

            //OPC读取三种方式：同步 异步 订阅
            //KepGroup.SyncRead(); 同步
            //KepGroup.AsyncRead(); 异步  
            //KepGroup.DataChange(); 订阅

            if (KepServer!=null&& this.OPCVarList.Count > 0)
            {
                //同步读取
                //KepGroup.SyncRead();
                //异步读取
                KepGroup.AsyncRead(this.OPCVarList.Count, ref ServerHandles, out ServerErrors, TransactionID, out CancelID);
            }

        }

        /// <summary>
        /// 异步读取完成事件
        /// </summary>
        /// <param name="TransactionID"></param>
        /// <param name="NumItems"></param>
        /// <param name="ClientHandles"></param>
        /// <param name="ItemValues"></param>
        /// <param name="Qualities"></param>
        /// <param name="TimeStamps"></param>
        /// <param name="Errors"></param>
        private void KepGroup_AsyncReadComplete(int TransactionID, int NumItems, ref Array ClientHandles, ref Array ItemValues, ref Array Qualities, ref Array TimeStamps, ref Array Errors)
        {
            //数据解析
            for(int i=1;i<=NumItems;i++)
            {
                object value = ItemValues.GetValue(i);
                int clientHandle = Convert.ToInt32(ClientHandles.GetValue(i));
                for(int j=0;j<this.OPCVarList.Count;j++)
                {
                    if(j+1==clientHandle)
                    {
                        this.OPCVarList[j].OPCValue = value.ToString();
                        this.OPCVarList[j].Quality = Qualities.GetValue(i).ToString();
                        this.OPCVarList[j].UpdateTime = TimeStamps.GetValue(i).ToString();
                    }
                }
            }
            this.dgvData.DataSource = null;
            this.dgvData.DataSource = this.OPCVarList;
            
        }
        #endregion
    }
}


由于DLL文件是32位的，所以只能编译为32位的程序，点击运行：



三个通道访问同一个数据都正常。
五、采用UDP通信
设置一个UDP通道，设置好端口号。



在PLC参数设置中添加一个UDP通道：


运行Quick Client,通信正常



C#监控程序正常工作。

1.并行通信

一次同时传送多位数据的通信方法叫做并行通信。其优点是传送速度高，缺点是数据有多少位，就需要多少根传送线。并行通信靠并行接口来实现。串行通信分为同步通信和异步通信。

2.串行通信

与并行通信相对，如果不是同时传送多位信号，而是将信号一位一位地传送，这种通信方式就称为串行通信。其优点是只需要一对传输线，缺点是传送速率较低。串行通信通过串行接口来实现，一般电脑都会有两个外置的COM口，这就是串行通信。

网络游戏分为客户端和服务端两部分，顾名思义客户端就是运行在用户的电脑或者手机上，服务端程序运行在游戏运营商的服务器上。
多个客户端通过网络与服务端进行通信。大多数的网络游戏因为要同时处理与很多很多玩家的通信，游戏服务器通常采用分布式架构，不同的服务端负责不同区的玩家。
服务端与客户端通常使用TCP网络进行通讯。于是就要提到网络编程的基础：Socket。
网络上的两个程序要进行数据交换，是通过一个双向的通信连接实现数据交换，连接的一端称为一个Socket，而一个Socket包含了进行网络通信必需的五个信息：连接使用的协议，本地主机的IP地址，本地的协议端口，远程主机的IP地址和远程协议端口。
端口就是设备与外界通信交流的出口。而Socket就可以看作是从一台计算机的一个端口连接到另外一个计算机的端口。当两个Socket相连接时，就可以进行网络通信。
每一个进程可以拥有多个Socket，每个Socket可以通过不同的端口与其它计算机连接。每一条Socket连接（可以把Socket连接看作一条网线通过这条网线进行数据传输），代表着Socket->本地端口->网络介质->远程端口->远程Socket链路。
TCP与UDP协议
TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议，而与之相对的UDP协议则是无连接的、不可靠的，但传输效率较高的协议。但这个专栏里的服务器实现，还是使用TCPi协议。
下面就在Unity里实现一个最基础的Echo程序，客户端向服务端发送一行文字，服务端收到消息后将文本发送回而客户端。
进入Unity之后先新建两个Button，一个是Connection，一个是SendButton，然后是一个输入框InputField和一个Text。下面是客户端的实现代码：
using 
在场景中随便拖给一个物体，然后给连接ConnectionButton绑定上Connection事件。但此时Unity会显示异常因为服务端还没有实现。
对于服务端的代码实现，每个服务端都可以大致把工作逻辑简化成：Socket创建->对创建的套接字进行绑定->开启监听，等待客户端连接->应答->接受客户端信息->回馈消息，即：
Socket->Bind->Listen->Accept->Recieve->Send
于是服务端代码实现如下：
using 
在运行服务端之后，在Unity中点击连接，再再InputField中输入要发送得文字，就可以向客户端发送输入得文本信息。
至此，最简单的客户端与服务端程序已经实现。这也是最简单的网络通信程序。
如果要更直观地了解客户端与服务端地工作方式以及作用，只需要修改一下EchoServer里的Send代码，就可以使客户端可以直接收到服务端发来的系统时间。
//Send
下面是运行结果图：
这只是一个开始，下面一篇文章会在这篇文章代码地基础上进行改进，实现异步和多路复用。