他小的有

树莓派4B安装docker+homeassistant

Tue, 29 Dec 2020 21:32:29 +0800

一、安装docker：

1.1 下载脚本

curl -fsSL https://get.docker.com -o get-docker.sh

1.2 以阿里云镜像安装脚本内容

sh get-docker.sh --mirror Aliyun

1.3 更换源

sudo nano /etc/docker/daemon.json

{
  "registry-mirrors": ["https://registry.docker-cn.com"]
}

1.4 设定开机启动和重启

sudo systemctl enable docker #开机启动
sudo systemctl start docker #启动

二、安装 homeassistant +HASS

2.1 安装armhf-hassio-supervisor镜像：

sudo docker pull homeassistant/armhf-hassio-supervisor:latest

2.2 安装armhf-homeassistant镜像

sudo docker pull homeassistant/armhf-homeassistant:latest

2.3 运行

sudo docker run -d \
 --name="home-assistant" \
 -v /home/pi/homeassistant:/config \
 -v /etc/localtime:/etc/localtime:ro \
 --net=host \
 --restart=always \
 homeassistant/armhf-homeassistant

树莓派4B无显示器安装系统

Sun, 27 Dec 2020 23:32:00 +0800

准备软件：

1.SD Card Formatter：SDCardFormatterv5_WinEN.zip（格式化TF卡工具）

2.Win32DiskImager：Win32DiskImager-1.0.0-src.zip（系统镜像烧录工具）

3.Raspberry Pi OS：2020-12-02-raspios-buster-armhf-full.zip（树莓派官方系统，第一次使用建议下载完整桌面版）

4.Putty：putty-64bit-0.74-installer.msi（SSH远程工具）

第一步：将TF卡插入读卡器并插入电脑，使用SD Card Formatter工具进行格式化TF卡

第二步：下载树莓派系统并解压，解压之后得到一个.img文件，使用Win32DiskImager将该文件并烧录到TF卡中，写入完成时系统可能提示需要格式化，此时不要格式化

第三步：为了能让系统开机之后自动连线WIFI，需要新建一个wpa_supplicant.conf文件，并填入以下内容，复制到boot根目录

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=CN

network={
	ssid="WIFI名称"
	psk="WIFI密码"
	key_mgmt=WPA-PSK
	priority=10
}

第四步：默认情况下树莓派是关闭SSH的，需要新增一个ssh文件（不要带后缀）并放入boot根目录让其开机时打开SSH以便连接，然后将TF卡从读取卡器取出并插入树莓中，启动树莓派

第五步：打开路由器查看树莓派连接的IP地址，使用Putty工具进行连接，默认用户名：pi，密码：raspberry，输入密码时看不到字符变化，输入完毕回车即可

至此整个树莓派系统安装就完成了。

树莓派默认使用的国外的源，访问速度较慢，这里建议更换为清华大学开源软件镜像站，使用管理员权限，编辑/etc/apt/sources.list文件

sudo nano /etc/apt/sources.list

用#注释掉原文件内容，并在最后添加如下内容（建议直接复制粘贴避免拼写错误）

deb http://mirrors.tuna.tsinghua.edu.cn/raspbian/raspbian/ buster main non-free contrib
deb-src http://mirrors.tuna.tsinghua.edu.cn/raspbian/raspbian/ buster main non-free contrib

使用管理员权限，编辑/etc/apt/sources.list.d/raspi.list文件

sudo nano /etc/apt/sources.list.d/raspi.list

用#注释掉原文件内容，并在最后添加如下内容（建议直接复制粘贴避免拼写错误）

deb http://mirrors.tuna.tsinghua.edu.cn/raspberrypi/ buster main ui

然后按下Ctrl+X退出，会提示是否需要保存，输入y然后回车确定即可

最后执行更新

sudo apt-get update
sudo apt-get upgrade

第一句是更新你的源列表，换源后必须执行。

第二句为是更新软件，如果你对新版本软件的需求不是那么迫切，可以不执行。

其它：

修改时区：

sudo timedatectl set-timezone Asia/Shanghai

结束！

Python脚本自动修改.rc文件版本号

Sat, 31 Oct 2020 17:29:34 +0800

发布软件时，需要修改.rc文件的版本号再编译工程，以便于当模块出现问题快速确定所使用模块的版本号，可使用Python在编译前进行自动修改版本号再编译发布：

//util_modify_rc_file_version.py

# modify .rc file version
import sys,re

if __name__=="__main__":
    filename = sys.argv[1]
    version = sys.argv[2]
    versionMacro = version.replace('.', ',')
    versionString = version.replace(',', '.')
    filename = filename.replace("\\\\","\\")
    f = open(filename, 'r', encoding='utf-16')
    lines = f.readlines()
    newLines = []
    for line in lines:
      if line.startswith(' FILEVERSION '):
        line = ' FILEVERSION ' + versionMacro + '\n'
      elif line.startswith(' PRODUCTVERSION '):
          line = ' PRODUCTVERSION ' + versionMacro + '\n'
      else:
          line = re.sub( r'(\s+VALUE\s"FileVersion",\s+)"(.*)"',r'\1"%s"' % versionString, line)
          line = re.sub( r'(\s+VALUE\s"ProductVersion",\s+)"(.*)"',r'\1"%s"' % versionString, line)
      newLines.append(line)

    f.close()
    f = open(filename, 'w', encoding='utf-16')
    f.writelines(newLines)
    f.close()

示例：

python "C:\util_modify_rc_file_version.py" "C:\demo.rc" "1.2.3.4"

说明：传入的第一个参数是要修改的.rc文件路径，第二个参数是版本号

其它：配合Jenkins在发布时自动修改版本号效果更佳，一劳永逸 :)

注意：我当前使用的是VS2015生成的.rc文件默认编码是utf-16 little endian，其它编码请自行修改打开和保存.rc文件的编码，另外要在执行这个脚本修改.rc文件版本后再编译项目哟~

C++ std::cout在cmd输出中文乱码的解决方案

Sat, 11 Jul 2020 15:07:25 +0800

1.如果是命令行的方式，在执行命令前先执行

chcp 65001

2.通过system命令修改编码

#include "stdafx.h"
#include <Windows.h>
#include <iostream>

int main()
{
    system("chcp 65001");

    std::cout << u8"中华人民共和国" << std::endl;

    std::system("pause");
    return 0;
}

缺点：会额外输出 Active code page: 65001 字符串。

3.通过SetConsoleOutputCP函数修改编码

#include "stdafx.h"
#include <Windows.h>
#include <iostream>

int main()
{
    SetConsoleOutputCP(CP_UTF8);

    std::cout << u8"中华人民共和国" << std::endl;

    std::system("pause");
    return 0;
}

Windows字符串编码转换，char/wchar_t/utf-8之间相互转换

Sun, 05 Jul 2020 22:43:25 +0800

字符串乱码往往是由于编码不一致或编码没有对应的字符所致，为了能够正常显示字符串，经常会有需要编码转换的需要，为了方便使用这里整理成一个head-only文件，这里提供了char、wchar_t、utf-8之间的转换，在实际的项目中建议使用wchar_t/utf-8，强烈建议使用utf-8。

//ZEncode.hpp

#pragma once
#include <Windows.h>
#include <string>
#include <vector>
#include <assert.h>

/*!
 * 编码转换命名空间
 * 
 */
namespace ZEncode
{
	/*!
	 * 窄字节转宽字节
	 * 
	 * \param str 窄字节
	 * \param uCodePage 窄字节编码
	 * \return 宽字节
	 */
	static std::wstring A2W(const std::string &str, UINT uCodePage)
	{
		int nLength = ::MultiByteToWideChar(uCodePage, 0, str.c_str(), -1, NULL, 0);
		if (0 == nLength)
		{
			throw std::exception("A2W Error");
		}
		std::wstring strW(nLength, L'\0');
		int nResult = ::MultiByteToWideChar(uCodePage, 0, str.c_str(), -1, &strW[0], nLength);
		if (nResult != nLength)
		{
			throw std::exception("A2W Error");
		}
		strW.resize(nLength - 1);
		return strW;
	}

	/*!
	 * 宽字节转窄字节
	 * 
	 * \param str 宽字节
	 * \param uCodePage 窄字节编码
	 * \return 窄字节
	 */
	static std::string W2A(const std::wstring &str, UINT uCodePage)
	{
		int nLength = ::WideCharToMultiByte(uCodePage, 0, str.c_str(), -1, NULL, 0, NULL, NULL);
		if (0 == nLength)
		{
			throw std::exception("W2A Error");
		}
		std::string strA(nLength, '\0');
		int nResult = ::WideCharToMultiByte(uCodePage, 0, str.c_str(), -1, &strA[0], nLength, NULL, NULL);
		if (nResult != nLength)
		{
			throw std::exception("W2A Error");
		}
		strA.resize(nLength - 1);
		return strA;
	}

	/*!
	 * 窄字节转窄字节
	 * 
	 * \param str 窄字节
	 * \param uCodePageFrom 源始字节编码
	 * \param uCodePageTo 目标字节编码
	 * \return 窄字节
	 */
	static std::string A2A(const std::string &str, UINT uCodePageFrom, UINT uCodePageTo)
	{
		return W2A(A2W(str, uCodePageFrom), uCodePageTo);
	}

	/*!
	 * 检查缓冲区数据是否是UTF-8
	 * 
	 * \param pBuffer 缓冲区
	 * \param size 大小
	 * \return 如果是返回true，否则返回false。
	 * 
	 * \note 返回结果并不一定完全正确，仅作为一个参考用途。
	 */
	static bool IsUTF8(const void* pBuffer, size_t size)
	{
		//参考 http://blog.csdn.net/bladeandmaster88/article/details/54767487
		bool bIsUTF8 = true;
		unsigned char* start = (unsigned char*)pBuffer;
		unsigned char* end = (unsigned char*)pBuffer + size;

		while (start < end)
		{
			if (*start < 0x80) // (10000000): 值小于0x80的为ASCII字符     
			{
				start++;
			}
			else if (*start < (0xC0)) // (11000000): 值介于0x80与0xC0之间的为无效UTF-8字符     
			{
				bIsUTF8 = false;
				break;
			}
			else if (*start < (0xE0)) // (11100000): 此范围内为2字节UTF-8字符     
			{
				if (start >= end - 1)
					break;

				if ((start[1] & (0xC0)) != 0x80)
				{
					bIsUTF8 = false;
					break;
				}
				start += 2;
			}
			else if (*start < (0xF0)) // (11110000): 此范围内为3字节UTF-8字符
			{
				if (start >= end - 2)
					break;

				if ((start[1] & (0xC0)) != 0x80 || (start[2] & (0xC0)) != 0x80)
				{
					bIsUTF8 = false;
					break;
				}
				start += 3;
			}
			else
			{
				bIsUTF8 = false;
				break;
			}
		}

		return bIsUTF8;
	}

	/*!
	* 检查字符串是不是UTF-8编码
	*
	* \param str 缓冲区
	* \return 如果是返回true，否则返回false。
	* 
	* \note 返回结果并不一定完全正确，仅作为一个参考用途。
	*/
	static bool IsUTF8(const std::string &str)
	{
		return IsUTF8(str.c_str(), str.size());
	}
}

//为了方便方便使用定义的宏
#define ANSI_TO_WCHAR(str)         (ZEncode::A2W(str, CP_ACP))
#define ANSI_TO_UTF8(str)          (ZEncode::A2A(str, CP_ACP, CP_UTF8))

#define UTF8_TO_ANSI(str)          (ZEncode::A2A(str, CP_UTF8, CP_ACP))
#define UTF8_TO_WCHAR(str)         (ZEncode::A2W(str, CP_UTF8))

#define WCHAR_TO_ANSI(str)         (ZEncode::W2A(str, CP_ACP))
#define WCHAR_TO_UTF8(str)         (ZEncode::W2A(str, CP_UTF8))

测试用例（备注：Windows中文版环境[gb2312]，Visual Studio默认文件编码[gb2312]）：

/***** ZEncode *****/
namespace ZEncodeTest
{
	TEST(ZEncode, ansi_to_wchar_to_ansi)
	{
		std::string strANSI("中华人民共和国");
		std::wstring strWChar = ANSI_TO_WCHAR(strANSI);
		EXPECT_STREQ(strWChar.c_str(), L"中华人民共和国");
		EXPECT_STREQ(WCHAR_TO_ANSI(strWChar).c_str(), "中华人民共和国");
	}

	TEST(ZEncode, ansi_to_utf8_to_wchar)
	{
		std::string strANSI("中华人民共和国");
		std::string strUTF8 = ANSI_TO_UTF8(strANSI);
		EXPECT_FALSE(ZEncode::IsUTF8(strANSI));
		EXPECT_TRUE(ZEncode::IsUTF8(strUTF8));
		EXPECT_STREQ(UTF8_TO_WCHAR(strUTF8).c_str(), L"中华人民共和国");
	}

	TEST(ZEncode, ansi_to_utf8_to_ansi)
	{
		std::string strANSI("中华人民共和国");
		std::string strUTF8 = ANSI_TO_UTF8(strANSI);
		EXPECT_FALSE(ZEncode::IsUTF8(strANSI));
		EXPECT_TRUE(ZEncode::IsUTF8(strUTF8));
		EXPECT_STREQ(UTF8_TO_ANSI(strUTF8).c_str(), strANSI.c_str());
	}

	TEST(ZEncode, wchar_to_utf8_to_wchar)
	{
		std::wstring strWChar(L"中华人民共和国");
		std::string strUTF8 = WCHAR_TO_UTF8(strWChar);
		EXPECT_TRUE(ZEncode::IsUTF8(strUTF8));
		EXPECT_STREQ(UTF8_TO_WCHAR(strUTF8).c_str(), strWChar.c_str());
	}
}

其它：在C++11中，如果希望初始化的字符串编码为utf-8，只需要在字符前面新增u8即可，如下：

std::string s1 = "中华人民共和国";  //取决于文件编码
std::string s2 = u8"中华人民共和国";  //utf-8编码

Jenkins执行Python脚本时如何获取WORKSPACE，JOB_NAME

Sun, 05 Jul 2020 10:47:50 +0800

通过Jenkins上的Python插件执行Python脚本时可通过环境变量的方式获取WORKSPACE，JOB_NAME的方法示例：

import os
workspace=os.environ['WORKSPACE']
jobName=os.environ['JOB_NAME']
print workspace
print jobName

使用devenv命令来编译解决方案下的工程

Fri, 03 Jul 2020 23:28:41 +0800

在自动集成和发布中（如果Jenkins），经常需要命令行的形式来启动Visual Studio来编译项目，可以使用devenv来启动Visual Studio编译项目工和，如下：

devenv "%WORKSPACE%\Demo.sln" /build Debug /project "Project1\Project1.vcxproj" /projectconfig Debug
devenv "%WORKSPACE%\Demo.sln" /build Release /project "Project1\Project1.vcxproj" /projectconfig Release

从Nuget导入包之后，提示头文件和函数未找到的问题

Wed, 27 Mar 2019 13:53:45 +0800

从nuget导入包到程序中时，可以正常包含头文件，也可以正常使用函数和编译，但是在IDE中显示无法找到头文件和无法跳转到函数，提示函数未定义，如下图所示：

解决方案：关闭项目，删除*.VC.db文件，重新打开项目即可。

清除Nuget本地缓存

Sat, 09 Mar 2019 23:51:28 +0800

场景：在Nuget服务器上发布相同的版本号的包，在客户端Nuget获取的包不是服务器最新版本时，可通过清除本地缓存再重新拉取包可解决这个问题。

解决方案：打开Nuget控制台，执行清除本地缓存

注意事项：需要先下载nuget.exe，并添加到环境变量（在控制台输入nuget命令有对应的信息）

nuget locals all -clear

操作步骤：Tools -> NuGet Package Manager -> Package Manager Colsole

输入上面的命令回车即可：

此时再拉取对应的包即可。

C++ std::string format 函数

Wed, 16 Aug 2017 19:53:28 +0800

#include <string>
#include <vector>

/**
 * 格式化字符串
 * 
 * \param pszFmt 格式描述
 * \param ... 不定参数
 * \return 格式化的结果字符串
 */
std::string format(const char *pszFmt, ...)
{
	std::string str;
	va_list args;
	va_start(args, pszFmt);
	{
		int nLength = _vscprintf(pszFmt, args);
		nLength += 1;  //上面返回的长度是包含\0，这里加上
		std::vector<char> chars(nLength);
		_vsnprintf(chars.data(), nLength, pszFmt, args);
		str.assign(chars.data());
	}
	va_end(args);
	return str;
}

//使用示例：
char c = 'A';
std::string str = format("c=%c", c);  // c=A
	
int i = 10;
str = format("i=%d", i);  // i=10

double d = 1.5;
str = format("d=%f", d);  // d = 1.500000

std::string strName = ("txdy");
str = format("I am %s", strName.c_str());  // I am txdy

这样，就可以很方便的格式化字符串了，程序中使用字符串是最常见的操作了，自己也可以封装一个CString类将其归类起来，方便以后的项目中使用。