<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>Posts on 菜菜博士</title>
    <link>https://microcai.org/posts/index.html</link>
    <description>Recent content in Posts on 菜菜博士</description>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <lastBuildDate>Mon, 16 Nov 2026 00:00:00 +0800</lastBuildDate>
    <atom:link href="https://microcai.org/posts/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>神密的负扭矩</title>
      <link>https://microcai.org/2026/11/16/what-neg-torque.html</link>
      <pubDate>Mon, 16 Nov 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/11/16/what-neg-torque.html</guid>
      <description>&lt;p&gt;注：本文所有公式都会省略一个固定的常量。这些常量是使用国际单位制的时候为了校准结果而存在的。但是本文的公式没有默认单位制。&lt;/p&gt;
&lt;h1 id=&#34;负扭矩是什么&#34;&gt;负扭矩是什么&lt;/h1&gt;
&lt;p&gt;扭矩有方向。让电机正转的扭矩，就是正扭矩。
让电机反转的扭矩，就是负扭矩。
同理，正转的时候，就是正转速。
反转的时候，就是负转速。&lt;/p&gt;
&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34; display=&#34;block&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;电机输出的机械功率&lt;/mtext&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;扭矩&lt;/mtext&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mtext&gt;转速&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;
电机输出的机械功率 = 扭矩 \times 转速
&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;p&gt;因此，&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;正扭矩&lt;/mtext&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mtext&gt;负转速&lt;/mtext&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;负功率&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;正扭矩 \times 负转速 = 负功率&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;负扭矩&lt;/mtext&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mtext&gt;正转速&lt;/mtext&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;负功率&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;负扭矩 \times 正转速 = 负功率&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;所谓负功率，说明电机在吸收机械功率。能量是守恒的，他吸收的机械功率，就要变成电能。&lt;/p&gt;
&lt;p&gt;因此，我们说负功率下，电机在发电。&lt;/p&gt;
&lt;p&gt;通常，电机正转时，输出负扭矩，就是在发电。&lt;/p&gt;
&lt;p&gt;是这样的吗？&lt;/p&gt;
&lt;h1 id=&#34;负扭矩会发电吗&#34;&gt;负扭矩会发电吗？&lt;/h1&gt;
&lt;p&gt;电机带着负载高速正转时，如果要求电机输出负扭矩，就是主动对负载减速，然后反转。
在这个过程中，电机会先发电，然后耗电。&lt;/p&gt;
&lt;p&gt;因为，反转后，&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;负扭矩&lt;/mtext&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mtext&gt;负转速&lt;/mtext&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;正功率&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;负扭矩 \times 负转速 = 正功率&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;但是，并不是减速到0后开始反转电机才耗电，在接近0转速的时候，电机就已经退出发电状态进入耗电了。&lt;/p&gt;
&lt;p&gt;这里面的机制是这样的：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;电机带着负载高速正转时，输出负扭矩靠的是，控制器输出比反电动势低的电压，迫使反电动势让电流倒转 —— 电流从电机流向直流母线，然后进入电池。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;随着转速的下降，反电动势越来越低，如果还靠吸收反电动势产生负扭矩是不够的。因此电机此时通过反转来输出负扭矩。所以，在接近0转速的时候，电机就已经退出发电状态进入耗电了。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;最后转速到0，乃至开始反转，电机就彻底的负扭矩+负转速了。负负得正，耗电是理所当然的啦。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这里面难理解的地方，就在于，为何正转+负扭矩不一定会发电？&lt;/p&gt;
&lt;h1 id=&#34;发电这个事情&#34;&gt;发电这个事情&lt;/h1&gt;
&lt;p&gt;我们断开控制器，就只保留电机。把电机转起来，电机的线圈就会切割磁感应线。天然的就会发出电压。&lt;/p&gt;
&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34; display=&#34;block&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;发电电压&lt;/mtext&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;转速&lt;/mtext&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mtext&gt;磁通量&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;发电电压 = 转速 \times 磁通量&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;p&gt;接上负载就会发电。&lt;/p&gt;
&lt;p&gt;但是，他发出的电压，正比于转速。
意味着：当他接入电源当电动机用的时候，只有发的电压超过电源，能量才能反向流回电源。而他发电等于电源电压的转速，恰好就是空载转速。&lt;/p&gt;
&lt;p&gt;只有超过空载转速才能发电啊！&lt;/p&gt;
&lt;p&gt;发电才能输出负功率。所以电机不超过空载转速不能输出负功率？&lt;/p&gt;
&lt;p&gt;非也。&lt;/p&gt;
&lt;p&gt;控制器是可以对电机发出的电进行升压的。&lt;/p&gt;
&lt;p&gt;当控制器输出 三相全低电压 时，3个桥臂的下管一起导通。这等于直接短路了电机的绕组。
于是，电机发出来的反电动势，就会直接作用于电机的绕组，是的绕组的电流提高。
接着，MOS管关闭。电感电流不能突变！于是，电流需要强行流过，咋办？ 自然就是冲破MOS自带的体二极管，于是电流就从电机流向直流母线，然后进入电池。为何一定要这么流？ 因为6个体二极管的方向决定了，只能这么流。&lt;/p&gt;
&lt;p&gt;所以， 控制器只要不断的 三相短路-开路，就可以实现电机的发电。不需要电机发的电压高于母线电压。控制短路的时间占比就能控制发电功率，也就是控制负扭矩。&lt;/p&gt;
&lt;p&gt;但是，这并不是实现负扭矩的方式。&lt;/p&gt;
&lt;p&gt;我们来看，这种方式有什么问题。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;他在低速下，无法实现大的负扭矩。&lt;/p&gt;
&lt;p&gt;低速下，电机的反电动势就小，即便100%短路三相绕组，也不足以产生足够的电流。于是，低于某个转速后，想要的负扭矩就无法维持了。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;他无法自然的通过反扭矩实现反转。&lt;/p&gt;
&lt;p&gt;最终转速到 0 后，控制器必须重新切换到驱动模式，才能实现反转。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;</description>
    </item>
    <item>
      <title>误差控制和残差控制原理</title>
      <link>https://microcai.org/2026/11/11/diff-ctl.html</link>
      <pubDate>Wed, 11 Nov 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/11/11/diff-ctl.html</guid>
      <description>&lt;h1 id=&#34;误差控制和残差控制&#34;&gt;误差控制和残差控制&lt;/h1&gt;
&lt;p&gt;传统控制的核心思想是误差。误差控制的目标是使系统输出与期望输出之间的误差最小化。
而残差控制的核心思想是残差。残差控制的目标是使系统输出与预测输出之间的残差最小化。&lt;/p&gt;
&lt;p&gt;在传统的控制理论里，观测是独立于控制的。观测数据来自传感器。
观测数据的更新，会导致误差的更新。
误差的更新，最后导致控制量的更新。&lt;/p&gt;
&lt;p&gt;在残差控制律里，观测和控制是统一的。观测和控制，都会产生残差。
即：观测残差 更新模型参数，控制残差 更新控制参数。&lt;/p&gt;
&lt;p&gt;即：控制律有 观测和控制2个拍，交织在一起运行。
观测残差告诉你，模型哪里错了。控制残差告诉你，控制量哪里错了。&lt;/p&gt;
&lt;p&gt;残差和误差，说的是维度。误差是个标量，残差是个矢量。&lt;/p&gt;
&lt;p&gt;这就导致了，对于  &amp;gt;1 个控制量的系统。
对每一个控制量，都需要运行一个独立的误差控制。为了避免多个误差控制环相互打架的问题，
要求控制量之间必须解耦。&lt;/p&gt;
&lt;p&gt;而残差控制，没有这个必须解耦的限制。
因为残差控制是基于残差的。残差是个矢量，所以可以同时控制多个控制量，控制量之间可以耦合。&lt;/p&gt;
&lt;h1 id=&#34;残差控制律&#34;&gt;残差控制律&lt;/h1&gt;
&lt;p&gt;在残差控制律下，控制系统是一个 多输入多输出的闭环控制系统。&lt;/p&gt;
&lt;p&gt;控制律运行的时候，需要把控制逻辑分成3个拍：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;观测残差&lt;/li&gt;
&lt;li&gt;控制残差&lt;/li&gt;
&lt;li&gt;更新预测&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这3个拍可以交织运行，也可以异步运行。即：观测和控制运行速度不一致。&lt;/p&gt;
&lt;p&gt;具体在代码上，需要一个 状态空间。状态空间里，存储系统模型参数，预测输出，控制参数。&lt;/p&gt;
&lt;p&gt;观测步骤：观测和预测的残差，通过残差传播的方式，更新模型参数。&lt;/p&gt;
&lt;p&gt;控制步骤：根据观测和控制目标的残差，通过残差传播的方式，更新控制参数。&lt;/p&gt;
&lt;p&gt;更新预测：根据系统状态空间和状态转移方程，更新预测输出。&lt;/p&gt;
&lt;p&gt;这3个步骤首尾相连运行，形成一整个闭环控制环。&lt;/p&gt;
&lt;p&gt;每个步骤里，都会更新自己的协方差矩阵。预测的时候，这个矩阵告诉你，我的预测会随着时间发散。
观测的时候，这个矩阵告诉你，我的观测有多少相干性。
控制的时候，这个矩阵告诉你，我的控制量有多少耦合性。&lt;/p&gt;
&lt;h1 id=&#34;收敛过程&#34;&gt;收敛过程&lt;/h1&gt;
&lt;p&gt;不管是误差控制，还是残差控制，都有一个收敛过程。
系统在更新控制量的时候，不需要一步到位的给出准确的控制量。
系统会通过迭代，逐渐收敛到一个稳定的状态。&lt;/p&gt;
&lt;p&gt;收敛速度，又被称为系统带宽。&lt;/p&gt;
&lt;p&gt;注意：系统带宽和控制律的执行带宽并不等价。
系统带宽是一个收敛的过程。他天然的低于执行带宽。除非做到理论上的单拍收敛。&lt;/p&gt;
&lt;p&gt;高精度控制的优化目标就是2条腿走路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;提高执行带宽。&lt;/li&gt;
&lt;li&gt;提高收敛速度。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;为什么闭环系统并不追求单拍收敛呢？&lt;/p&gt;
&lt;p&gt;因为单拍收敛，需要完美的模型。
而完美的模型，是不存在的。
所以，闭环系统并不追求单拍收敛。&lt;/p&gt;
&lt;p&gt;承认模型是不完美的，再通过小步快跑的方式逼近控制目标。&lt;/p&gt;
&lt;h1 id=&#34;解耦和正交&#34;&gt;解耦和正交&lt;/h1&gt;
&lt;p&gt;即便用了残差控制，状态空间依然需要满秩。
向量之间要满足正交性。
但是，正交性是数学上的。耦合性是物理上的。&lt;/p&gt;
&lt;p&gt;例如 D轴和Q轴，数学上是正交的，物理上是有耦合的。&lt;/p&gt;
&lt;h1 id=&#34;残差转播&#34;&gt;残差转播&lt;/h1&gt;
&lt;p&gt;残差传播的方式，可以使用机器学习！&lt;/p&gt;</description>
    </item>
    <item>
      <title>学习型残差实验观测器：基于机器学习和主动实验的电机参数观测器</title>
      <link>https://microcai.org/2026/10/31/a-new-sensorless-foc-algo.html</link>
      <pubDate>Sat, 31 Oct 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/10/31/a-new-sensorless-foc-algo.html</guid>
      <description>&lt;!-- ============================================================
  双用途说明（源码注释，不渲染）：
  本文同时是期刊投稿草稿。投稿时：
  1) 删除「写在前面」（博客按语）整节；
  2) 删除「附录 C：思想脉络」整节；
  3) 补全参考文献中标注 ⟨待核实⟩ 的条目；
  4) 用真实仿真/实验数据填充第 VII 节的占位表格；
  5) 「记号约定与替换表」改为标准符号表（Nomenclature），删除对《新数学语言倡议》的引用；若期刊要求符号公式，可将正文汉语公式换回符号形式并以本表对照。
  其余正文即为论文格式。
============================================================ --&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;写在前面（博客按语，投稿时删除）&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这篇东西的想法，来自我突然想到的一个类比：电机控制里的&lt;strong&gt;高频注入&lt;/strong&gt;（High-Frequency Injection），本质上是一次&lt;strong&gt;主动式侧信道提取&lt;/strong&gt;——往系统里打一个已知的高频信号，电流响应本来是「本职」驱动信号的副产物，但转子的位置就藏在这个副产物里。既然信息藏在残差里，那「预测—残差—校正」的观测器闭环就是解码器。&lt;/p&gt;
&lt;p&gt;问题从「怎么从高频响应里抠位置」变成了一个更根本的问题：**什么时候才需要打这个高频？**传统做法是看转速表——低速开、高速关。我认为真正合理的做法是看信息是否充分：系统自己判断当前是不是看不清了（后验不确定性变大、某些方向长期没被观测照亮），才主动制造一场高频注入；看清楚了就闭眼省电。&lt;/p&gt;
&lt;p&gt;最贴切的画面是一种危险驾驶行为：困了在高速上开车，闭目养神，时不时睁眼看一下路况。什么时候睁眼？不看时刻表，看困不困。当然，工程上还得回答「睁眼值不值」（注入有损耗和转矩脉动的代价）和「是不是眼睛坏了」（模型失配时注入救不了，得报警），这两点正是本文代价门控和三分支决策的来历。&lt;/p&gt;
&lt;p&gt;这个观测器起名&lt;strong&gt;学习型残差实验观测器&lt;/strong&gt;（英文名 Learning Residual-Experiment Observer，缩写 LREO）：残差是学习的素材，注入是设计的实验，「学习型」点明它与机器学习同源；「实验」二字指在线的实验设计动作，不是离线物理实验。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;名词速查&lt;/strong&gt;（博客读者用，投稿时删除）：&lt;strong&gt;残差/新息&lt;/strong&gt; = 预测值与实测值之差；&lt;strong&gt;先验/后验&lt;/strong&gt; = 用观测修正之前/之后对状态的信念；&lt;strong&gt;协方差矩阵 P&lt;/strong&gt; = 信念的「不确定度」，P 大 = 看不清；&lt;strong&gt;Fisher 信息矩阵&lt;/strong&gt; = 历史观测对每个方向的「照明强度」；&lt;strong&gt;凸极&lt;/strong&gt; = 直轴电感 Ld 与交轴电感 Lq 不相等；&lt;strong&gt;占空比&lt;/strong&gt; = 注入时间占比。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;阅读指南&lt;/strong&gt;：懂电机与估计理论的读者直接从第 I 节读起；只想看思想脉络的，读这段按语加附录 C；所有推导细节在正文和附录 A、B。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr&gt;
&lt;h1 id=&#34;学习型残差实验观测器基于机器学习和主动实验的电机参数观测器&#34;&gt;学习型残差实验观测器：基于机器学习和主动实验的电机参数观测器&lt;/h1&gt;
&lt;p&gt;**作者：DR&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;单位：&lt;/strong&gt; （略）&lt;/p&gt;
&lt;h2 id=&#34;摘要&#34;&gt;摘要&lt;/h2&gt;
&lt;p&gt;传统高频注入无传感器控制通常按转速阈值开关注入，属于开环策略：它既不区分当前不确定性来自「转子位置不可观测」还是「参数耦合导致残差不可解释」，也不权衡注入带来的损耗与转矩脉动。本文提出一种&lt;strong&gt;学习型残差实验观测器&lt;/strong&gt;（Learning Residual-Experiment Observer, LREO）。本文所称「实验」，指观测器在后验不确定性超过门限时主动触发的一次受控高频注入探测——它不是离线物理实验，而是在线实验设计动作。方法面向凸极式（内置式）永磁同步电机：凸极差既是高频位置信号的来源，也决定了位置观测的灵敏度与信噪比上限。学习型残差实验观测器在一个联合状态—参数贝叶斯后验中同时维护转子位置、转速、定子电阻、永磁磁链与电感的不确定性；利用带遗忘因子的累积 Fisher 信息矩阵监测各状态方向的可辨识性，仅当后验协方差与信息矩阵最小特征值构成的双判据同时满足时，触发一次对准缺失可辨识方向的受控高频注入；新息一致性检验进一步将「信息不足」与「模型失配」区分开，前者触发实验，后者触发告警。注入产生的响应不作为独立高频观测器的输出，而是作为额外观测行块进入同一次贝叶斯更新，从而在联合协方差中显式记录状态—参数耦合。本文给出注入前后信息增益的解析预测式与代价门控判据，论证连续注入收益二次衰减的机制、并据此预期注入行为稀疏；同时给出覆盖温漂、退磁、负载突变等工况的仿真验证方案。须如实说明：本文的定量证据暂缺，验证停留在方案设计阶段，全部定量性能主张有待仿真与实机数据检验。该框架将无传感器估计表述为流式观测下的在线学习问题。最后讨论触发阈值整定、磁极极性管理与模型失配下的方法边界。&lt;/p&gt;</description>
    </item>
    <item>
      <title>从内外相聊古代皇权制度问题</title>
      <link>https://microcai.org/2026/10/29/neixiang-weixiang.html</link>
      <pubDate>Thu, 29 Oct 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/10/29/neixiang-weixiang.html</guid>
      <description>&lt;p&gt;权臣不得善终的问题困扰了中国古代一千多年。
朱元璋会因为胡惟庸请军官吃饭而认为他谋反。
赵王却会因为廉颇和蔺相如关系好而觉得于国有大利。
这种思维的转变是怎么来的呢？&lt;/p&gt;
&lt;h1 id=&#34;先说规矩&#34;&gt;先说规矩&lt;/h1&gt;
&lt;p&gt;汉武帝之前，帝国的权力格局是这样的：&lt;/p&gt;
&lt;p&gt;皇帝掌握立法权和监督权。宰相掌握行政权，宰相府就是中央政府。&lt;/p&gt;
&lt;p&gt;政府这个词，得先掰成两半。&lt;/p&gt;
&lt;p&gt;广义的政府，就是管理这个国家的全部机构。照这个口径，议会也是政府的一部分，当然有立法权。狭义的政府，特指受议会监督和授权而组建的那套行政班子，比如白宫。狭义的政府没有立法权，因为它是被授权、被监督的。&lt;/p&gt;
&lt;p&gt;放到古代：广义的中央政府是朝廷，皇帝和他的大臣们；狭义的中央政府，其实就是宰相府。&lt;/p&gt;
&lt;p&gt;我们分析现代国家的时候，很自然地接受议会和政府分开。但一研究历史就容易迷糊，张口就是“皇帝是中央政府的首脑”。这个迷糊不是无缘无故的，正是汉武帝之后，皇帝真的下场兼任了狭义政府的首脑，后人拿后半段的常识，去套了前半段的历史。&lt;/p&gt;
&lt;p&gt;打个现代的比方。想象这样一个美国：众议院议长掌握立法权，顺便监督行政。白宫只管行政，总统不能跑进议会讨论，只能执行议会表决后的结果。议长也不插手白宫的日常事务。二者边界清晰，井水不犯河水。&lt;/p&gt;
&lt;p&gt;议长就是皇帝，白宫就是宰相。&lt;/p&gt;
&lt;p&gt;皇帝的意志怎么实现？任命宰相，向宰相下达敕令，宰相去执行。皇帝自己不下场。&lt;/p&gt;
&lt;p&gt;宰相干得不好怎么办？换掉。但换人要给出信服的理由，不能随心所欲。因为这期间的冲突，是皇帝行使监督权产生的冲突，不是两个人抢行政权产生的冲突。监督者对执行者说“你不行，换人”，是一回事；两个执行者抢同一块地盘，是另一回事。性质完全不同。&lt;/p&gt;
&lt;p&gt;武帝之前，宰相从不会单纯因为皇帝的忌惮而被弄死。李斯是死了，可他是被赵高弄死的，不是皇帝在权力斗争中杀宰相。&lt;/p&gt;
&lt;p&gt;这个规矩再往上追，周代就有。“礼乐征伐自天子出”。礼乐不是晚宴礼仪，那就是周朝的宪法。征伐就是宣战权，和现代国家的宣战权归议会一个道理。天子管立法，行政交给卿相。立法者不直接行政，这是从周代传下来的老规矩。&lt;/p&gt;
&lt;h1 id=&#34;内相登场&#34;&gt;内相登场&lt;/h1&gt;
&lt;p&gt;汉武帝坏规矩，是从一个很具体的困局开始的。&lt;/p&gt;
&lt;p&gt;他换不掉宰相。宰相是太后任命的。&lt;/p&gt;
&lt;p&gt;窦太后的人当着宰相，武帝的意志落不下去。按老规矩，他可以行使监督权，给出理由换人。可宰相背后是太后，这条路走不通。&lt;/p&gt;
&lt;p&gt;换不掉，就另起一套人马来分权。尚书、侍中、给事中，这些皇帝身边的近臣组成了内朝。这就是内相。&lt;/p&gt;
&lt;p&gt;还是用美国的比方：议长为了自己工作方便，私设了一个“议长办公室”。议长办公室的工作内容，居然和白宫重叠！&lt;/p&gt;
&lt;h1 id=&#34;内相和外相是两种权力&#34;&gt;内相和外相，是两种权力&lt;/h1&gt;
&lt;p&gt;先把话说明白：外相的相权，就是独立的行政权。内相没有自己的权力，他实际上是代行皇权。&lt;/p&gt;
&lt;p&gt;外相的权力，是皇帝授予之后独立行使的。相府是正式机构，丞相有正式官衔，行政权在制度轨道上运转。权力一旦授出，就是他的。皇帝想收回？得走程序，得给出信服的理由。&lt;/p&gt;
&lt;p&gt;内相的权力，是皇帝开心了赏你的。这份权力从来不属于他，他只是替皇帝办事的手，他行使的每一分权力，都是皇权本身，他不过代行而已。皇帝开心，你就有权；不开心，随时收走。这不叫“授”，这叫“赏”。而且授予没有边界。&lt;/p&gt;
&lt;p&gt;外相的授权，有边界。边界就是：只有行政权，没有立法权。总统能参与议会讨论吗？不能！他只能执行议会表决后的结果。法律怎么定、定成什么样，外相插不上嘴。他干得再好，也只是个执行者。&lt;/p&gt;
&lt;p&gt;内相的授权，没有边界。代行皇权，皇权有多大，他的手就能伸多长：既可以攫取行政权，也可以窃取皇权本身。今天赏你起草诏书，明天就能赏你出纳王命，后天废立皇帝，也不过是代行皇权的一次正常发挥。霍光能废皇帝，靠的哪里是行政权？那是皇权本身的延伸。&lt;/p&gt;
&lt;p&gt;一句话：外相独享行政权，内相和皇帝分享皇权。&lt;/p&gt;
&lt;p&gt;回到美国的比方，这个区别就是几条腿的区别。&lt;/p&gt;
&lt;p&gt;外相就像白宫只有一条腿：行政。总统不能参与议会讨论。&lt;/p&gt;
&lt;p&gt;内相就好像议长办公室（现实没有，只是理论上的），它有两条腿：作为议长的私人代表，它能参与议会讨论；同时，它的人入驻白宫建筑干活。立法权和行政权，被它同时踩在脚下。&lt;/p&gt;
&lt;p&gt;两条腿意味着什么？意味着议长办公室可以用议长的立法权给自己授权，再用白宫的行政资源把授权变成既成事实。整个流程里，要摆平的只有议长一个人。&lt;/p&gt;
&lt;p&gt;这就是内相。这就是汉武帝发明的东西。&lt;/p&gt;
&lt;h1 id=&#34;裁判下场&#34;&gt;裁判下场&lt;/h1&gt;
&lt;p&gt;武帝之前，宰相的工作能力是第一位的。萧何、曹参、周勃，个个能镇住场面。&lt;/p&gt;
&lt;p&gt;武帝之后，忠诚是第一位的。&lt;/p&gt;
&lt;p&gt;因为内相的本色就是忠诚。内相是皇帝的触手，不需要能力强，棘手的费脑子的活，外相已经干过了。触手只要一条：听话。&lt;/p&gt;
&lt;p&gt;武帝朝前后十几位丞相，善终者寥寥。李蔡自杀，赵周下狱死，公孙贺拜相时痛哭流涕不肯接印，最后还是死在狱里，刘屈氂腰斩。皇帝要的不再是能治理帝国的人，而是一枚不添乱的图章。&lt;/p&gt;
&lt;p&gt;皇帝自己呢？他下场了。&lt;/p&gt;
&lt;p&gt;按老规矩，皇帝约束臣下的办法是立法：立规矩，监督执行，不行就换人。&lt;/p&gt;
&lt;p&gt;按美国的制度，议会对总统不满意了，可以弹劾。这就是监督权的正确用法：用程序换人。但议会再不满意，也不会自己去包揽行政——监督者一旦下场抢执行权，监督本身就没有了。&lt;/p&gt;
&lt;p&gt;汉武帝干的就是后一件事。皇帝亲自抓行政，裁判变成了运动员。运动员不会给自己立规则。于是“用立法权约束行政”的思路被整体抛弃，换成了“争夺行政权来约束臣下”。&lt;/p&gt;
&lt;p&gt;皇帝本来就不应该参与行政。这个道理，从汉武帝带歪之后，就再也没有皇帝看出来了。后面的几百个皇帝，都积极地参与行政。&lt;/p&gt;
&lt;h1 id=&#34;权臣为什么不得善终&#34;&gt;权臣为什么不得善终&lt;/h1&gt;
&lt;p&gt;现在可以回答开头的问题了。&lt;/p&gt;
&lt;p&gt;总统会威胁议长的地位吗？不会。哪怕两人吵得面红耳赤，也不会想到要物理消灭对方。因为这是两个有独立权力基础的角色，各有各的合法性来源，冲突再大也有程序可走。&lt;/p&gt;
&lt;p&gt;但议长办公室里的某个能人，是真的可能让议长觉得：此人控制不住，不如除掉。&lt;/p&gt;
&lt;p&gt;因为这个能人的权力完全派生自议长个人。办公室是议长私设的，没有独立合法性。议长对他没有任何制度性的约束手段，你不能弹劾自己家的秘书，剩下的选项只有物理消灭。&lt;/p&gt;
&lt;p&gt;外相就是总统，内相就是那个能人。&lt;/p&gt;
&lt;p&gt;霍光以内相身份掌权，废立皇帝，权倾天下。他一死，全家族诛。此后东汉的外戚宦官，魏晋的权臣，轮流上演同一个剧本。不是皇帝一代比一代残暴，是内相的权力结构里，冲突本来就没有和平出口。&lt;/p&gt;
&lt;p&gt;武帝之后，皇帝和宰相必有一个认怂。皇帝强，则宰相沦为傀儡；宰相强，则皇帝沦为傀儡。&lt;/p&gt;
&lt;p&gt;武帝之前不是这样。春秋战国，国君和宰相可以同时强势。管仲相齐，齐桓公照样称霸。廉颇掌军，蔺相如为相，将相和，赵国兴盛，赵王乐得坐享其成。因为那时候权力合法性是多源的，将相各有独立根基，他们联合起来干活不威胁王位。&lt;/p&gt;
&lt;h1 id=&#34;阿斗的运气&#34;&gt;阿斗的运气&lt;/h1&gt;
&lt;p&gt;整个帝制史上，武帝之后把老规矩捡回来的只有一例：诸葛亮和阿斗。&lt;/p&gt;
&lt;p&gt;诸葛亮开府治事，总领全国军政。这不是专权，这就是丞相的本职工作，外相的规矩。阿斗那边，“政由葛氏，祭则寡人”，自己只管祭祀。皇帝忍住不用内相，外相守住行政边界，互不侵犯，于是成了君臣典范。&lt;/p&gt;
&lt;p&gt;有人说诸葛亮权倾朝野，和鳌拜无异。单看权力实态，确实差不多。但诸葛亮不是鳌拜，因为阿斗不是康熙。刘禅手里握着最终的人事权和裁决权：诸葛亮死后，一个叫李邈的跳出来把诸葛亮比作权臣，暗示该清算，刘禅直接把他砍了。阿斗用皇权宣告：这条路线不容挑战。&lt;/p&gt;
&lt;p&gt;没有阿斗，诸葛亮就是鳌拜。阿斗是诸葛亮权力合法化的必要条件。这对君臣是彼此成就的，缺了哪一方都不成立。&lt;/p&gt;
&lt;p&gt;可惜，后面的皇帝再也没有阿斗的运气。&lt;/p&gt;
&lt;h1 id=&#34;外相没了&#34;&gt;外相没了&lt;/h1&gt;
&lt;p&gt;到了隋唐，外相直接被撤销了。&lt;/p&gt;
&lt;p&gt;三省六部制，中书出令，门下封驳，尚书执行。这三省长官，全是过去的内相，被外相化了。&lt;/p&gt;
&lt;p&gt;用美国的比方：白宫被废除了。然后，议长办公室的人入驻白宫建筑群干活。&lt;/p&gt;
&lt;p&gt;门牌换了，官署是正式的了，官衔俸禄都齐了。但权力派生自皇帝的逻辑没有变，他们每天早上还是先给议长打电话请示。&lt;/p&gt;
&lt;p&gt;更糟的是，内相一旦常态化，就再也没有“忍住不用”的选项。外相时代，皇帝还可以像阿斗那样克制。现在满朝都是内相谱系，皇帝就是想甩手也不行，制度迫使他们和内相斗个你死我活。唐后期宦官掌枢密，废立皇帝如儿戏。内相的权力，大到可以直接决定议长的人选了。&lt;/p&gt;
&lt;h1 id=&#34;朱元璋的悖论&#34;&gt;朱元璋的悖论&lt;/h1&gt;
&lt;p&gt;一千多年的君相内耗，最后由朱元璋来了结。&lt;/p&gt;
&lt;p&gt;他看到了病根：皇权和相权斗了一千多年，没完没了。于是干脆废掉中书省，撤了丞相，六部直接对皇帝负责。&lt;/p&gt;
&lt;p&gt;皇帝兼任宰相。千古一绝。&lt;/p&gt;</description>
    </item>
    <item>
      <title>资本主义绝户计论：税基转移与人口再生产的制度危机</title>
      <link>https://microcai.org/2026/10/25/capitalism-juehuji.html</link>
      <pubDate>Sun, 25 Oct 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/10/25/capitalism-juehuji.html</guid>
      <description>&lt;h2 id=&#34;摘要&#34;&gt;摘要&lt;/h2&gt;
&lt;p&gt;本文提出&amp;quot;资本主义绝户计&amp;quot;命题：现代资本主义的财政与社会保障制度以劳动人身为实际税基、以资产为豁免对象，把劳动力再生产的社会成本转嫁给家庭，使&amp;quot;不生&amp;quot;成为个体的理性选择，最终以生育率崩塌完成对劳动者的双重抽取。文章先以清代&amp;quot;摊丁入亩&amp;quot;为参照建立分析框架，指出当代趋势是&amp;quot;摊亩入丁&amp;quot;——税基从财产滑回人身；继而解剖现行制度的三重抽取管道，论证搭便车死局使人口再生产的崩溃成为必然；最后给出破解方案：再来一次方向相反的&amp;quot;摊丁入亩&amp;quot;，即从人头税转向资产税，并论证其技术可行性与政治条件——资本害怕没有利润，但更害怕死亡。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;关键词&lt;/strong&gt;：资本主义绝户计；摊丁入亩；摊亩入丁；劳动力再生产；现收现付制；资产税；搭便车&lt;/p&gt;
&lt;h2 id=&#34;一引言&#34;&gt;一、引言&lt;/h2&gt;
&lt;p&gt;&amp;ldquo;资本主义绝户计&amp;quot;原是中文互联网上的批判性修辞。&amp;ldquo;绝户计&amp;quot;在传统语境中兼有两重痛感：香火断绝与财产被夺。这个词的流行，指认的是一种结构性感受：资本的运行逻辑正在摧毁人组建家庭、养育后代的条件。&lt;/p&gt;
&lt;p&gt;本文不满足于把它当作情绪化修辞，而是将其提升为可论证的政治经济学命题，其核心链条有四步：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;资本需要源源不断的劳动力，却拒绝支付劳动力的再生产成本；&lt;/li&gt;
&lt;li&gt;现代财政与社保制度以劳动（人身）为实际税基、以资产为豁免对象，在制度层面放大了这一拒绝；&lt;/li&gt;
&lt;li&gt;养育成本私人化、养老收益公共化的制度安排，使&amp;quot;不生&amp;quot;成为个体的理性选择；&lt;/li&gt;
&lt;li&gt;无数个体理性的聚合，就是人口再生产的集体崩溃。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;二税基在人还是在资产&#34;&gt;二、税基在人还是在资产&lt;/h2&gt;
&lt;p&gt;判断一种财政制度是否构成&amp;quot;绝户计&amp;rdquo;，标准只有一个：**它向什么征税，以及养育后代的成本由谁承担。**中国赋税史为此提供了一个现成的参照系。&lt;/p&gt;
&lt;h3 id=&#34;21-摊丁入亩税基脱离人身&#34;&gt;2.1 摊丁入亩：税基脱离人身&lt;/h3&gt;
&lt;p&gt;清雍正朝完成的摊丁入亩，把延续约两千年、按人丁征收的丁银摊入田赋。国家的征税依据从&amp;quot;你家里有多少人&amp;quot;改为&amp;quot;你占有多少地&amp;rdquo;。多生一个儿子不再意味着多一份税，压在&amp;quot;添丁&amp;quot;上的直接税负惩罚被解除。清代人口从乾隆初年的约 1.7 亿增至嘉庆年间的 3.6 亿；其间虽有统计口径与多因之辩，但&amp;quot;人身税负的解除释放了生育&amp;quot;这一机制方向是确定的。&lt;/p&gt;
&lt;p&gt;摊丁入亩的历史分量在于一项原则的确立：&lt;strong&gt;不因为一个人&amp;quot;存在&amp;quot;而向他征税，只向资源的拥有者征税。&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;22-摊亩入丁税基滑回人身&#34;&gt;2.2 摊亩入丁：税基滑回人身&lt;/h3&gt;
&lt;p&gt;以此观照当代，趋势恰恰相反：税负与生存成本的重心，正从财产滑回人身。一个典型例证是职工医保最低缴费年限延长至男 30 年、女 25 年——个体必须用生命时间中可劳动的部分去&amp;quot;兑换&amp;quot;未来的保障，制度成本深嵌入人身存在。这不是形式上的按人定额，而是税负归宿重新锚定在&amp;quot;劳动&amp;quot;这一人身维度上。本文把这一趋势概括为&amp;quot;摊亩入丁&amp;quot;，并判断：**摊亩入丁是资本主义绝户计的重要一环。**至于这一判断的经验基础——现行税制如何在细节上多重课征劳动而豁免资产——留待第三节展开。&lt;/p&gt;
&lt;h3 id=&#34;23-税基是否锚在人身决定生育的兴衰&#34;&gt;2.3 税基是否锚在人身，决定生育的兴衰&lt;/h3&gt;
&lt;p&gt;两个时代的对照给出一个可操作的判断标准：当制度使养育后代成为纯粹的经济负担时，生育被系统性抑制；当税基与&amp;quot;人的存在&amp;quot;解绑时，被压抑的生育意愿便释放。据此，人口危机的财政根源可以一句话点破：**税基又滑回了&amp;quot;人&amp;quot;。**以下两节检验这个诊断。&lt;/p&gt;
&lt;h2 id=&#34;三现行制度的三重抽取&#34;&gt;三、现行制度的三重抽取&lt;/h2&gt;
&lt;h3 id=&#34;31-税制归宿多重课征劳动制度性豁免资产&#34;&gt;3.1 税制归宿：多重课征劳动，制度性豁免资产&lt;/h3&gt;
&lt;p&gt;先看税制的整体结构。
向劳动者征收的税，主要是所得税和社保，税率 45% 和 16%+8% (最低缴纳基准导致实际税率对低收入者可能超过 50%)。
向企业征收的税，主要是增值税和企业所得税，税率是 13% 和 25%，有大量的抵扣和免税通道
向富人征税： 主要是资本利得税，税率 20%，并且有大量的免税通道&lt;/p&gt;
&lt;p&gt;“打工的”在顶格纳税，“开公司的”在合法避税，“靠资产的”在轻松减免。&lt;/p&gt;
&lt;p&gt;这就是&amp;quot;摊亩入丁&amp;quot;在税制细节上的完整形态。&lt;/p&gt;
&lt;h3 id=&#34;32-社保披着保险外衣的雇佣税&#34;&gt;3.2 社保：披着保险外衣的雇佣税&lt;/h3&gt;
&lt;p&gt;社保在征收端具有完全的强制性与累退性：法定义务、不可退出、锚定工资、资本所得不入费基。这两点正是税收的定义特征。它自称&amp;quot;保险&amp;quot;，制度收益是双重的：既享有强制征收的普遍性，又绕开了税收法定与预算审查——&amp;ldquo;费&amp;quot;不进一般公共预算程序，不接受针对&amp;quot;税&amp;quot;的那套立法约束。而财政补贴逐年扩大这一事实，本身就证伪了它的独立&amp;quot;保险&amp;quot;属性；财政兜底的支出却按&amp;quot;多缴多得&amp;quot;分配，等于用全体纳税人的钱奖励正式雇佣身份，构成逆向再分配。征收端按税的逻辑强制，支出端却按保险的逻辑对价——这个矛盾如何解开，留待第五节。&lt;/p&gt;
&lt;p&gt;现收现付制使这笔&amp;quot;税&amp;quot;的抽取结构变得具体：当前在职者的缴费直接支付当前退休者的养老金。于是出现一个尖锐的断裂——进城打工的年轻人缴纳职工社保，供养的是城市退休职工；他们自己的父母作为农村居民，领取的城乡居民基础养老金长期只有每月一百余元。&lt;strong&gt;一个农民工的缴费支撑的是别人的父母，自己的父母几乎不在统筹体系的有效保障范围内。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;传统上养老靠孩子；&amp;ldquo;政府给你养老&amp;quot;的承诺诱导年轻人在奉献劳动的同时放弃生育。但这个承诺是选择性的，而非虚假的：政府确实在养老，养的是体制内与城镇职工，不是所有人。缴费义务通过劳动年龄人口被普遍化，待遇却在人群之间极不均等。绝户计的抽取落点正在这里：让最缺乏议价能力的劳动人口同时承担缴费义务与家庭养老的剩余责任，却不获得对等保障。其结果是代际转移的倒置——&lt;strong&gt;现在的年轻人是啃老，而不是养老&lt;/strong&gt;：被制度抽干的年轻人，反过来要靠父母做家庭最后的安全网。&lt;/p&gt;
&lt;h3 id=&#34;33-混池用保险逻辑执行税收强制&#34;&gt;3.3 混池：用保险逻辑执行税收强制&lt;/h3&gt;
&lt;p&gt;机关事业单位与城镇职工养老保险并轨&amp;quot;混池&amp;quot;之后，产生一批结构性怪象。体制内退休金按退休前工资的高替代率计发，缺口由劳动缴费与财政补贴填补；公务员下海后缴费年限不足，则用&amp;quot;视同缴费&amp;quot;等账面年限补足——本质是用账面年限把税收承诺伪装成保险对价。混池的实质是一个问题：&lt;strong&gt;公共供养的责任到底走税收明账，还是走劳动工资暗账？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;公职人员的退休金，应该属于税收供养。但是他们从社保领取养老金，变成了事实上从劳动者的工资里抽水供养。
如果通过税收供养公职人员的退休金，意味着全社会共同承担。劳动者虽然也承担，但是资本家也要承担。
而通过社保供养，意味着资本被豁免了供养责任。只有底层劳动者，才承担公职人员的退休供养责任。而且承担比例几乎按人头，而不是按收入。&lt;/p&gt;
&lt;p&gt;其动态后果是一个自我强化的循环：体制内待遇不能降，支出刚性增长；费基是工资池，相对萎缩；于是提高缴费基数、延长缴费年限、延迟退休依次登场。每一轮&amp;quot;改革&amp;quot;都把更重的抽取压回劳动人身。同时，社保按工资总额附加征收，实质是对雇佣行为课税：它推高正式雇佣的边际成本，把企业推向劳务派遣与零工就业，反过来又窄化费基、加剧缺口。分配的错位至此完全显形：公共财政的供养大头来自资本与企业所得的税收，而社保的供养大头几乎全部压在劳动工资上。&lt;strong&gt;用工资这个小池子去兜公共供养的大支出，循环只会越转越紧。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;正如崇祯把税负都压在了还未破产的农民身上。&lt;/p&gt;
&lt;h2 id=&#34;四诊断之二为什么崩溃是必然的&#34;&gt;四、诊断之二：为什么崩溃是必然的&lt;/h2&gt;
&lt;h3 id=&#34;41-成本与收益的割裂&#34;&gt;4.1 成本与收益的割裂&lt;/h3&gt;
&lt;p&gt;现收现付制把养老从家庭内部的代际契约改成社会统筹的代际契约，却没有解决一个根本错位：**养育孩子的成本由家庭私人承担，孩子长大后的劳动成果却由全社会共享。**你生孩子，你承担全部成本，而你的孩子缴的社保养的是全社会的老人；你不生孩子，你省下全部成本，老了照样领别人家孩子缴的养老金。两相比较，不生最划算。&lt;/p&gt;
&lt;h3 id=&#34;42-别人家的孩子搭便车死局&#34;&gt;4.2 &amp;ldquo;别人家的孩子&amp;rdquo;：搭便车死局&lt;/h3&gt;
&lt;p&gt;这就是&amp;quot;靠别人家的孩子养老&amp;quot;的搭便车逻辑。当所有人都如此推理，公地悲剧便上演：每个人都想免费享用&amp;quot;下一代劳动&amp;quot;这个公共品，却没有人愿意承担生产它的成本。生育率跌到 1.0，不是某个人的选择，而是全社会搭便车激励下的个体理性，汇聚成集体的不育。&lt;/p&gt;</description>
    </item>
    <item>
      <title>新数学语言倡议</title>
      <link>https://microcai.org/2026/10/09/new-math-lang.html</link>
      <pubDate>Fri, 09 Oct 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/10/09/new-math-lang.html</guid>
      <description>&lt;p&gt;写代码的写代码的人都知道，变量名要自解释：&lt;code&gt;customerLifetimeValue&lt;/code&gt;、&lt;code&gt;retentionRate&lt;/code&gt;、&lt;code&gt;discountFactor&lt;/code&gt;。可一写公式，一切退化回 &lt;code&gt;L&lt;/code&gt;、&lt;code&gt;r&lt;/code&gt;、&lt;code&gt;d&lt;/code&gt;。三页之后，&lt;code&gt;L&lt;/code&gt; 从损失变成拉格朗日量，&lt;code&gt;r&lt;/code&gt; 从利率变成半径，&lt;code&gt;d&lt;/code&gt; 从折扣因子变成微分算子。读者只能靠上下文和自己的信仰活着。&lt;/p&gt;
&lt;p&gt;这流传了几百年的陋习，却被说成简洁和优美。&lt;/p&gt;
&lt;h2 id=&#34;一病根省略乘号&#34;&gt;一、病根：省略乘号&lt;/h2&gt;
&lt;p&gt;单字母公式的根源，既不是前人精密，也不是排版逼仄，而是一条几乎没人注意的语法铁律：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;并列即相乘。&lt;/strong&gt; &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;ab&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt; 就是 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;a \times b&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;。&lt;/p&gt;
&lt;p&gt;这条规则看着无害，却从语法底层摁死了多字母变量：你想写 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;r&lt;/mi&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mi&gt;t&lt;/mi&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;rate&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;，公式会自动帮你解析成 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;r&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;t&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;r \times a \times t \times e&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;。&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;s&lt;/mi&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;speed&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt; 就是 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;s&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;s \times p \times e \times e \times d&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;。&lt;/p&gt;
&lt;p&gt;所以单字母根本不是审美选择，是被语法&lt;strong&gt;逼&lt;/strong&gt;出来的唯一解。多字母变量在数学里事实上不可用——除非动用 &lt;code&gt;\text{}&lt;/code&gt;、花体、加粗、下标这些残废补丁，代价是排版丑、嵌套崩、平方像在给单词乘方。&lt;/p&gt;
&lt;p&gt;一句话：数学符号系统为了手写和排版的极简，把本该由编译器干的&amp;quot;分词&amp;quot;，外包给了读者的工作记忆。写起来爽，读起来死。&lt;/p&gt;
&lt;h2 id=&#34;二共犯英语霸权&#34;&gt;二、共犯：英语霸权&lt;/h2&gt;
&lt;p&gt;如果说省略乘号是主犯，英语就是从犯。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;loss → L&lt;/code&gt;、&lt;code&gt;rate → r&lt;/code&gt;、&lt;code&gt;probability → p&lt;/code&gt;、&lt;code&gt;expectation → E&lt;/code&gt;。母语者看到 &lt;code&gt;L&lt;/code&gt; 自动联想到 loss；非母语者看到 &lt;code&gt;L&lt;/code&gt;，脑子里先蹦出 length、Lagrangian、Laplacian、likelihood、learning rate，全靠上下文硬猜。这不是公平的符号，这是给英语母语者的语感特权。&lt;/p&gt;
&lt;p&gt;更荒唐的是：论文正文用的是中文，公式里的变量却必须用英文首字母。正文翻译了，公式凭什么不翻译？把一个拉丁语系的缩写习惯，伪装成全人类的通用标准——这是语言上的双重标准。&lt;/p&gt;
&lt;h2 id=&#34;三倡议四条规则&#34;&gt;三、倡议：四条规则&lt;/h2&gt;
&lt;p&gt;于是，我提一份《新数学语言倡议》，共四条：&lt;/p&gt;
&lt;h3 id=&#34;规则一凡是给人类读的公式优先使用与正文语言一致的全称变量名并显式写出乘号&#34;&gt;&lt;strong&gt;规则一：凡是给人类读的公式，优先使用与正文语言一致的全称变量名，并显式写出乘号。&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;比如卡尔曼滤波的一步预测：&lt;/p&gt;
&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34; display=&#34;block&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;预预测状态向量&lt;/mtext&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;状态转移矩阵&lt;/mtext&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mtext&gt;上一时刻状态估计向量&lt;/mtext&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mtext&gt;控制作用矩阵&lt;/mtext&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;mtext&gt;控制输入向量&lt;/mtext&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mtext&gt;过程噪声向量&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;
预预测状态向量 = 状态转移矩阵 \times 上一时刻状态估计向量 + 控制作用矩阵 \times 控制输入向量 + 过程噪声向量
&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;p&gt;读者不需要背符号表，不用猜 &lt;code&gt;F&lt;/code&gt; 是不是状态转移矩阵。&lt;/p&gt;
&lt;h3 id=&#34;规则二演算阶段允许引入临时替换表把全称变量映射为局部短符号作用域仅限于该推导段落&#34;&gt;&lt;strong&gt;规则二：演算阶段，允许引入临时替换表，把全称变量映射为局部短符号，作用域仅限于该推导段落。&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;令：
&lt;/p&gt;
&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34; display=&#34;block&#34;&gt;&lt;semantics&gt;&lt;mtable rowspacing=&#34;0.25em&#34; columnalign=&#34;right left&#34; columnspacing=&#34;0em&#34;&gt;&lt;mtr&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;mi&gt;P&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;预测状态向量，&lt;/mtext&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;/mtr&gt;&lt;mtr&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;mi&gt;T&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;状态转移矩阵，&lt;/mtext&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;/mtr&gt;&lt;mtr&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;mi&gt;X&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;上一时刻状态估计向量，&lt;/mtext&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;/mtr&gt;&lt;mtr&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;mi&gt;C&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;控制作用矩阵，&lt;/mtext&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;/mtr&gt;&lt;mtr&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;mi&gt;U&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;控制输入向量，&lt;/mtext&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;/mtr&gt;&lt;mtr&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mstyle scriptlevel=&#34;0&#34; displaystyle=&#34;true&#34;&gt;&lt;mrow&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;mi&gt;N&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;过程噪声向量。&lt;/mtext&gt;&lt;/mrow&gt;&lt;/mstyle&gt;&lt;/mtd&gt;&lt;/mtr&gt;&lt;/mtable&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;
\begin{aligned}
&amp;amp; P = 预测状态向量，\\
&amp;amp; T = 状态转移矩阵，\\
&amp;amp; X = 上一时刻状态估计向量，\\
&amp;amp; C = 控制作用矩阵，\\
&amp;amp; U = 控制输入向量，\\
&amp;amp; N = 过程噪声向量。
\end{aligned}
&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;p&gt;则：&lt;/p&gt;</description>
    </item>
    <item>
      <title>解放战争拖不得</title>
      <link>https://microcai.org/2026/10/08/stupid-putting.html</link>
      <pubDate>Thu, 08 Oct 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/10/08/stupid-putting.html</guid>
      <description>&lt;p&gt;毛主席有两句话：&lt;strong&gt;抗日战争急不得，解放战争拖不得。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这两句看似矛盾，其实是同一台战略时钟的两面。这台时钟只量一件事：&lt;strong&gt;时间，站在谁那一边。&lt;/strong&gt; 拿它去量普京的乌克兰战争，会发现他每一个该死的节点，都恰好走反了。&lt;/p&gt;
&lt;p&gt;抗战为什么急不得？日本是工业强国，中国是农业弱国，正面决战等于送死，速胜论是幻想。拖下去，日本要陷入中国战场的泥潭，以小国占大国，每占一座城就多背一个包袱；国际形势会变，反法西斯阵营会成，美国会下场。所以时间在中国一边，《论持久战》算的就是这笔账。&lt;/p&gt;
&lt;p&gt;那解放战争为什么反过来拖不得？先澄清一个最常见的误读：&lt;strong&gt;不是怕打不过。&lt;/strong&gt; 国民党有美援又怎样？美械师照样在孟良崮、在三大战役里被成建制地吃掉。解放军从东北到长江，打赢的恰恰是拿着美国装备的对手。军事这一层，从头到尾都有底。&lt;/p&gt;
&lt;p&gt;真正怕的是另一笔账。要讲清这笔账，先记住一个前提：&lt;strong&gt;抗日战争是抵御外敌，解放战争是内战——战场上对面站着的，也是中国人。&lt;/strong&gt; 这个区别决定了一切。&lt;/p&gt;
&lt;p&gt;注意，&lt;strong&gt;&amp;ldquo;急不得&amp;quot;和&amp;quot;拖不得&amp;quot;不是两条互相打架的口号，而是同一个算法跑出来的两个结果。&lt;/strong&gt; 这个算法要问两问：&lt;strong&gt;一问，拖下去谁的力量在涨、谁在消？二问，拖下去是谁在签字卖地，将来又是谁来还债？&lt;/strong&gt; 抗战是外战，拖下去敌消我长，占下的每座城都是侵略者自己的包袱。解放战争是内战，对手美援打得再多，军事上照样赢；可拖下去真正在发生的事，是国民党拿着中国的家当去换军火——而它抵押出去的每一样东西，将来都要由中国人自己赎、自己还。这才是&amp;quot;越拖越亏&amp;quot;的那笔亏。&lt;/p&gt;
&lt;p&gt;这笔亏账，层层递进，至少有四层。&lt;/p&gt;
&lt;h2 id=&#34;第一层拖是看着敌人替你卖祖产&#34;&gt;第一层：拖，是看着敌人替你卖祖产&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;外援不是白给的，是要拿东西换的；而敌人能拿去换的，从来不是它自己的东西，是这个国家的家当。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;美援是什么？是贷款，是军售，是要拿港口、铁路、矿产、关税、驻军权、通商特权去签字画押的。国民党为了多打一天仗，就敢把主权一样样押出去：允许美国军舰进港、飞机落地，签出让利的商约，把战略物资和重建权益打包抵债。它今天签一张，明天签一张，拖得越久，押得越多。&lt;/p&gt;
&lt;p&gt;最要命的是这些债的归属。&lt;strong&gt;国民党是当时中国名义上的政府，它签的字、借的债、押出去的利权，法律上就是&amp;quot;中国&amp;quot;签的、借的、押的。&lt;/strong&gt; 等你仗打赢了、政权接过来了，这些白纸黑字不会因为换了旗帜就作废——矿还是别人控股，港口还停着别人的军舰，关税还攥在别人手里，重建的利润早被预约光了。你赢了战争，接手的却是一个被抵押干净的国家。&lt;/p&gt;
&lt;p&gt;那为什么不能干脆不认这些账，由着它卖？因为别忘了这是内战：&lt;strong&gt;国统区的人民，也是中国人。&lt;/strong&gt; 他们没投票要打这场仗，却要替国民党的美援买单——抵押出去的矿是他们的饭碗，押出去的铁路是他们的生计，出让的关税最后变成他们缴的税。&lt;strong&gt;不能因为一个人暂时活在敌对政权的治下，就不把他当自己人。&lt;/strong&gt; 解放战争要解放的，恰恰是这几万万还在国统区里的中国人。他们今天被国民党替着卖，明天解放了，债还要跟着他们还。看着敌人替他们卖祖产而无动于衷，等于默认他们不是中国人。&lt;/p&gt;
&lt;p&gt;所以速战速决的第一层含义，根本不是军事上的怕，是时间上的抢：&lt;strong&gt;趁国民党还没把家当卖光，赶紧把政权和签字权夺回来。&lt;/strong&gt; 每快一天结束战争，就少一批条约、少一笔外债、少一份要不回来的利权；救回来的不都是地盘，是国统区几万万人将来要过的日子。这才是&amp;quot;拖不得&amp;quot;最根本的一条。&lt;/p&gt;
&lt;h2 id=&#34;第二层拖就是替列强等干预的窗口&#34;&gt;第二层：拖，就是替列强等干预的窗口&lt;/h2&gt;
&lt;p&gt;比卖家当更凶险的，是大国直接下场安排中国的命运。&lt;/p&gt;
&lt;p&gt;1949 年解放军兵临长江，斯大林通过渠道带话，劝毛主席见好就收、不要过江，怕的是逼出美国干涉，落个&amp;quot;划江而治&amp;rdquo;。这是什么局面？就是&lt;strong&gt;南北朝&lt;/strong&gt;，就是让中国变成南北朝鲜、东西德、南北越南——同一个民族、同一种文字，被一条外人划下的线切成两个国家，然后对峙几十年、几代人，亲人老死不相往来。&lt;/p&gt;
&lt;p&gt;毛主席回了一句诗：&lt;strong&gt;&amp;ldquo;宜将剩勇追穷寇，不可沽名学霸王。&amp;rdquo;&lt;/strong&gt; 项羽当年在鸿门宴上心一软放了刘邦，落得乌江自刎；历史上但凡在决胜时刻停下来&amp;quot;苟一下&amp;quot;的，没有一个不是把苟来的喘息，变成了几百年的分裂。&lt;/p&gt;
&lt;p&gt;这一层的账是：&lt;strong&gt;拖，不只是在军事上给敌人时间，更是在政治上给列强时间。&lt;/strong&gt; 外部势力从反应过来、到统一意见、到武装干涉或强行调停，同样需要时间。快到他们来不及反应，既成事实摆在桌上，他们也只能认；慢到他们排好座次再上桌，连打的资格都不归你了。&lt;/p&gt;
&lt;h2 id=&#34;第三层拖就是替敌人留喘息&#34;&gt;第三层：拖，就是替敌人留喘息&lt;/h2&gt;
&lt;p&gt;第三层是战术层面的一条铁律：&lt;strong&gt;伤其十指，不如断其一指。&lt;/strong&gt; 注意，这一层同样不是因为怕打不赢——赢得了，也没必要反复赢。&lt;/p&gt;
&lt;p&gt;击溃战和歼灭战是两回事。把敌人打跑、打退、打散，他退下去休整三个月，抓了壮丁、补了枪弹，又是一支军队回来找你——这叫击溃，打多少场都不解决问题，本质是陪着敌人循环，而每循环一轮，前面三层的账（卖祖产、等干预、填人命）就重演一遍。歼灭战不一样，成建制地消灭他的有生力量，这一批老兵、军官、骨干没了就是没了，重新征兵从头练起，战斗力天差地别。要打歼灭战，就要&lt;strong&gt;集中优势兵力、连续作战、不给对手喘息&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;最能说明问题的就是林彪。&lt;/p&gt;
&lt;p&gt;辽沈战役刚打完，东北野战军疲惫到极点，林彪想&amp;quot;苟一下&amp;quot;——休整部队、巩固东北、补充兵员。从纯军事角度看，这天经地义。毛主席的电报却追着屁股催：&lt;strong&gt;不休整，立即入关。&lt;/strong&gt; 为什么不近人情？因为他看到的是傅作义在华北的几十万大军可能南撤西逃、和蒋介石合流，看到国民党还在一船船地往外押家当、列强还在排座次，看到战略窗口正在一寸寸关闭。结果东北野战军秘密提前入关，傅作义被分割包围在平津，想跑跑不掉；接着淮海、渡江，环环相扣，一气呵成。等列强深度反应过来，蒋介石连&amp;quot;划江而治&amp;quot;的谈判资格都没了。&lt;/p&gt;
&lt;p&gt;林彪心疼部队，是将领的视角；毛主席不许他停，是战略家的视角：&lt;strong&gt;决战时刻，停顿就是把时间和主动权一起送给敌人。&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&#34;第四层拖就是拿人命去填时间&#34;&gt;第四层：拖，就是拿人命去填时间&lt;/h2&gt;
&lt;p&gt;很多人以为穷追猛打残忍，缓一缓才人道。这笔账恰好算反了。&lt;/p&gt;
&lt;p&gt;战争最残忍的规律是：一旦拖入消耗，死的就不只是前线士兵了。前线绞肉、后方饥荒、瘟疫、经济崩溃，再加上外部势力介入后武器升级、仇恨固化，死人是以几何级数往上翻的。三国混战几十年，人口从东汉末年的五千多万掉到不足千万；南北朝、五代十国打了几百年，死人以千万计；太平天国拉锯十余年，数千万人填了进去。&lt;/p&gt;
&lt;p&gt;反过来看解放战争：1946 年全面内战爆发，到 1949 年基本统一大陆，只用了三年多，&lt;strong&gt;是中国几千年历史上死亡人口最少的统一战争。&lt;/strong&gt; 这不是因为战争仁慈，而是因为战略上根本没让它拖。三大战役加上大量起义、投诚、改编，把该打的硬仗压缩在最短时间里打完，然后停战、土改、重建，活人开始过日子。&lt;/p&gt;
&lt;p&gt;所以老话讲&lt;strong&gt;雷霆手段方显菩萨心肠&lt;/strong&gt;。这话听着狠，意思却是仁：&lt;strong&gt;用一场决战，替代无数场没完没了的小战；用短期的剧痛，换掉几代人的长痛。&lt;/strong&gt; 真正的菩萨心肠，不是不忍心打，而是不忍心让人民在无尽的战火里熬上几十年。拖，从来不是稳妥，拖是钝刀杀人。&lt;/p&gt;
&lt;h2 id=&#34;还有一个前提准备要慢开打要快&#34;&gt;还有一个前提：准备要慢，开打要快&lt;/h2&gt;
&lt;p&gt;讲到这里必须补一句，否则&amp;quot;拖不得&amp;quot;会被误读成冒进。&lt;/p&gt;
&lt;p&gt;&amp;ldquo;拖不得&amp;quot;约束的是&lt;strong&gt;开战之后&lt;/strong&gt;，它在开战之前还有个孪生兄弟，叫&lt;strong&gt;不打无准备之仗&lt;/strong&gt;。别看毛主席打起来追着敌人不让喘气，战前他比谁都能熬：土改、根据地、军队整编、情报网络、统一战线，扎扎实实准备了十几年；什么时候打、打哪里、打多大，反复掂量。重庆谈判时他敢亲自去，就是因为底气是准备出来的。&lt;/p&gt;
&lt;p&gt;所以完整的信条是两截：&lt;strong&gt;准备阶段，急不得，要熬到有把握；一旦开打，拖不得，要快到敌人来不及。&lt;/strong&gt; 慢，是为了攒足一击必杀的本钱；快，是为了不让准备好的时机白白烂掉。慢和快不矛盾，它们服务的是同一件事——毕其功于一役。&lt;/p&gt;
&lt;h2 id=&#34;一句话&#34;&gt;一句话&lt;/h2&gt;
&lt;p&gt;这就是&amp;quot;解放战争拖不得&amp;quot;六个字的全部内涵：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;拖，是看着敌人替你卖祖产，替列强等来切分你的刀，替败军留下卷土重来的本钱，替自己等来一个尸横遍野、满目疮痍的烂摊子。&lt;/strong&gt; 所以必须趁家当没卖光、列强没醒、敌阵未稳，集中兵力连续歼灭，一鼓作气把战争结束在窗口关闭之前。&lt;/p&gt;
&lt;p&gt;从头到尾，怕的都不是打不赢——打得赢。怕的是等你打赢的时候，赢回来的已经不是那个中国了。知道&amp;quot;快好&amp;quot;的是将领，知道&amp;quot;不快就全盘皆输&amp;quot;的才是战略家。&lt;/p&gt;
&lt;h1 id=&#34;二乌克兰的时钟在谁手里&#34;&gt;二、乌克兰的时钟在谁手里&lt;/h1&gt;
&lt;p&gt;把这台时钟搬到第聂伯河边上。&lt;/p&gt;
&lt;p&gt;从体量上说，乌克兰绝对打不过俄罗斯。人口差不多三比一，工业、能源、纵深全面劣势，没有外援，它连 2022 年春天都熬不过去。&lt;/p&gt;
&lt;p&gt;有人会说，乌克兰和当年的中国正好相反：解放军是有美援也打得过，乌克兰是离了外援立刻亡国。没错，两军的力量账是反的。但&amp;quot;拖不得&amp;quot;那台时钟的第一层——&lt;strong&gt;有人在拿家当换军火&lt;/strong&gt;——一模一样在转，甚至转得更露骨。当年是国民党替中国人卖中国，毛主席急，是因为卖的是自己人的家、自己将来要收回的国；现在是乌克兰替西方卖苏联留下的家底。普京本来该更急：他既然口口声声把苏联遗产当成自己要保的东西，那乌克兰每签一张矿产协议，都是在拆他要的那个盘。&lt;strong&gt;谁把那份家当认作自己的，谁就拖不得。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;但&lt;strong&gt;请外援是要付代价的，这个代价就是卖。&lt;/strong&gt; 西方的援助不是慈善，是交易：锂、钛、稀土、铁矿，苏联时期勘探布局的战略矿产；黑土地，欧洲的粮仓；安东诺夫、马达西奇、黑海造船厂这些苏联军工的遗腹子；敖德萨的港口，通往欧洲的能源管道；还有战后重建的特许经营权。今天签一个重建基金，明天签一个矿产协议，乌克兰在用国家的明天，换今天不亡国。&lt;/p&gt;
&lt;p&gt;账算到这一步，俄罗斯一方的战略时钟就清清楚楚了：&lt;strong&gt;每拖一天，乌克兰就多卖一天；每拖一天，西方资本就深绑一层；每拖一天，苏联留在乌克兰的家底就被二次瓜分一次；每拖一天，反俄就从乌西的口号变成全乌克兰的国策。&lt;/strong&gt; 2014 年的乌克兰还在东西摇摆，2022 年之后连俄语区都被炸出了乌克兰认同——这是时间替乌克兰完成的动员。&lt;/p&gt;</description>
    </item>
    <item>
      <title>科技树完备性优先于成本</title>
      <link>https://microcai.org/2026/10/02/system-cost-not-single-cost.html</link>
      <pubDate>Fri, 02 Oct 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/10/02/system-cost-not-single-cost.html</guid>
      <description>&lt;h1 id=&#34;从空x的成本开始想到的&#34;&gt;从空X的成本开始想到的&lt;/h1&gt;
&lt;p&gt;空X（SpaceX）一年发射一百多次，新增的一级火箭制造量却只有个位数。&lt;/p&gt;
&lt;p&gt;一次性火箭时代，发射次数等于制造数量，打一发少一发。复用把这个等式改了：2025 年猎鹰 9 号打了 165 次，而 2025 年初它曾用仅 4 枚新助推器支撑了 52 次发射。发射次数远大于制造数量，这就是它低成本神话的算术来源。&lt;/p&gt;
&lt;p&gt;这个账，从发射服务商的角度看是奇迹，从工业体系的角度看是另一回事。一个年发射一百多次的国家，火箭年制造量已经萎缩到十几枚。顺着这条线往下想，问题就来了：火箭到底为什么贵？省下来的钱又到底是从哪里省出来的？&lt;/p&gt;
&lt;h1 id=&#34;必须考虑生产线的维持成本&#34;&gt;必须考虑生产线的维持成本&lt;/h1&gt;
&lt;p&gt;火箭贵，首先不是材料贵。铝锂合金、碳纤维、高温合金再值钱，也不是一枚火箭成本的大头。大头是研发分摊、厂房设备、工装测试台、熟练工人和质量体系——这些全是固定成本，产量越低，摊到每枚箭上就越厚。行业里的经验数字是，一条火箭产线为了维持基本技艺不退化，每年至少得造 4 到 6 枚。&lt;/p&gt;
&lt;p&gt;复用省的是&amp;quot;再造一套硬件&amp;quot;的钱，但它同时减少了新造火箭的数量。固定成本一分没少，分摊的基数却变小了，单枚新箭的完全成本反而更高。迷惑性就在这里：发射方按&amp;quot;每枚火箭价格 ÷ 复用次数&amp;quot;算账，看到的是下降；改按&amp;quot;产线总成本 ÷ 发射次数&amp;quot;算账，固定成本这个刚性的分子就暴露了。发射端的单位成本降了，制造端的单位成本可能正在涨，总成本没有消失，只是被转移和延迟了。&lt;/p&gt;
&lt;p&gt;当年中国航天的老总对可复用火箭冷淡，理由就是这个：中国发射需求不高，真正的成本是养活几十万航天人，复用又不能少养一个人，只会让制造工人放假放得更长。有总师把门槛算得很直白——年发射量低于 50 次上下，一次性火箭的成本效益反而更优。后来低轨星座带来年均数百发的预期需求，中国才全力转向复用，这是后话。&lt;/p&gt;
&lt;p&gt;美国国防采购是同一套病，而且病得更系统。F-22 原本要 750 架，国会一路砍到 187 架，单机采购价从预估的 1.4 亿美元涨到 3.34 亿，然后国会看着价格说&amp;quot;太贵了，不买了&amp;quot;，2011 年关了生产线。他们只算了买飞机的账，没算养产线的账：近千家二级供应商永久销毁专用工装，一代钛合金加工和隐身技术的技工退休转行。2016 年空军想重启，算账结果是仅启动成本就要 99 亿美元、总投入超 500 亿，且航电早已过时，重启约等于重新研制，作罢。B-2 从 132 架砍到 21 架，朱姆沃尔特从 32 艘砍到 3 艘，同一个&amp;quot;死亡螺旋&amp;quot;反复上演。&lt;/p&gt;
&lt;p&gt;对照之下，中国的国家预算里，&amp;ldquo;军品生产线维持维护费&amp;quot;是和武器采购费分开列支的独立科目，还有专门的管理办法。这等于在制度上承认：维持一条产线本身就是一项国家成本，不买武器不等于不用花钱，今天不养线，明天想买的时候已经买不到了。&lt;/p&gt;
&lt;h1 id=&#34;必须考虑供应链的维持成本&#34;&gt;必须考虑供应链的维持成本&lt;/h1&gt;
&lt;p&gt;产线之外，还有更难重建的东西：供应链。而要理解空X低成本的不可持续性，先要看清一件事：&lt;strong&gt;它今天拿到的供应商报价，是不含养链成本的报价——还有同行在替它养这条链。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;供应链是一条共用品。一家阀门厂、一家碳纤维厂、一家发动机配件厂，其工装折旧、资质认证、核心技工工资，要靠所有客户的订单一起分摊。空X之外，ULA 的火神、波音的 SLS、五角大楼的导弹订单、欧空局的阿丽亚娜 6 号，都还在往这些供应商下单。正是这些&amp;quot;别人的订单&amp;rdquo;，把供应商的产线维持成本垫了起来，空X才能按接近边际成本的价格拿货。它的低成本里，有一部分是同行缴纳的补贴。&lt;/p&gt;
&lt;p&gt;换句话说，空X的效率账本和整条产业链的健康账本是两本账。它自己一年只造十几枚火箭，这个采购量根本养不活身后几百家供应商；它之所以还能买到便宜零件，是因为供应商此刻还没有只依赖它。这是典型的搭便车，只不过搭车人不知道、或不在乎桥正在被自己拆掉。&lt;/p&gt;
&lt;p&gt;补贴池正在快速干涸。火神火箭2025 年实际只飞了 1 次，随后停飞；新格伦炸了发射台，修复要等到 2028 年；阿丽亚娜 6 号年理论产能 11 枚，一年只打了 4 发；SLS 一年造不出一枚。当这些客户的订单萎缩或消失，供应商失去的不是某一笔生意，而是维持产线所需的分摊基数。于是行业里出现了理性的退出：有传统供应商干脆拒绝重新投标复合材料压力容器，因为这项太空业务占用了工程团队超过 30% 的时间，只换来个位数的收入占比——半导体和 AI 数据中心给出的订单，可比火箭稳定、量大得多。&lt;/p&gt;</description>
    </item>
    <item>
      <title>只有汉语能念出数学公式</title>
      <link>https://microcai.org/2026/10/01/only-han-can-read-math.html</link>
      <pubDate>Thu, 01 Oct 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/10/01/only-han-can-read-math.html</guid>
      <description>&lt;p&gt;汉语和数学语言是同构的。&lt;/p&gt;
&lt;p&gt;英语是&amp;quot;语法先行&amp;quot;的语言，汉语是&amp;quot;语义先行&amp;quot;的语言，而数学，是语义先行走到极致的产物。所以数学公式可以用汉语直接&lt;strong&gt;念&lt;/strong&gt;出来，用英语却只能&lt;strong&gt;翻译&lt;/strong&gt;。&lt;/p&gt;
&lt;h1 id=&#34;语义优先-vs-语法优先&#34;&gt;语义优先 vs 语法优先&lt;/h1&gt;
&lt;p&gt;先看句子。&lt;/p&gt;
&lt;p&gt;一个名词出现在动词的位置上，会发生什么？英语里只有两种结局：要么是病句，要么办手续——承认这个名词被转类成了动词，然后带上动词的全部形态变化。Google 本来是公司名，当了动词就得是 I &lt;strong&gt;Googled&lt;/strong&gt; it、He &lt;strong&gt;Googles&lt;/strong&gt; it，过去式、第三人称单数一个不能少。你说 I Google it yesterday，错的不是意思，是手续没办。&lt;/p&gt;
&lt;p&gt;汉语呢？&amp;ldquo;百度一下&amp;rdquo;、&amp;ldquo;微信我&amp;rdquo;、&amp;ldquo;咱们火锅吧&amp;rdquo;，名词直接进动词槽，词形不变，没有任何手续。能不能这么用，靠的是语义通不通：百度是工具，可以转指&amp;quot;用百度搜&amp;quot;；桌子转指不出任何动作，所以&amp;quot;我桌子一下&amp;quot;不行。&lt;strong&gt;英语像海关，词要换词性得先签证；汉语像市场，意思能听懂，词就能临时摆摊。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这就是两种语言的根本分野：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;英语&lt;/strong&gt;：形态和句法先搭好刚性模具，规定每个位置必须是什么范畴，语义再往格子里填。时态、单复数、主谓一致、冠词，全是强制的。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;汉语&lt;/strong&gt;：语义关系先搭起来，形式标记极少，范畴由位置和语境临时决定。&amp;ldquo;我吃了饭&amp;quot;和&amp;quot;饭我吃了&amp;rdquo;，位置变了，语义没变。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;有人拿&amp;quot;狗咬人 / 人咬狗&amp;quot;证明汉语也靠语序区分施受，这其实是犯了英语的毛病——用语法位置预设了一个现实中不存在的歧义。真实世界里狗只能咬人，语义和常识早就把施受关系锁死了，根本轮不到语序出场。英语不管这一套，Man bites dog 语法上完全合法，因为它的语法结构不关心现实，只关心形式。&lt;/p&gt;
&lt;h1 id=&#34;精确到底靠语法还是靠语义&#34;&gt;精确到底靠语法还是靠语义？&lt;/h1&gt;
&lt;p&gt;常见的崇拜是：英语精确，因为英语语法严密。&lt;/p&gt;
&lt;p&gt;这话经不起追问。人类手里最精确的语言是数学，而数学的语法简陋到可怜——无非是运算符、括号、变量的拼接，没有时态，没有单复数，没有冠词，没有从句嵌套。它能造出火箭、推出相对论，靠的不是语法复杂，而是&lt;strong&gt;每个符号的语义被定义绝对锁死了&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;a × b = b × a。这个式子说明的是：只要&amp;quot;乘法&amp;quot;的定义里包含交换律，a 和 b 谁在前谁在后，在语义上完全等价，位置退化成了纯粹的排版问题。a × (b + c) 和 a × b + c 不同，括号改变的也是&lt;strong&gt;运算次序&lt;/strong&gt;这个语义概念，而不是什么位置语法。数学里真正的语法错误（比如 a × + b）之所以错，是因为它对应不上任何有意义的运算——语法是为语义能被解析服务的，不是先于语义存在的规矩。&lt;/p&gt;
&lt;p&gt;反过来看英语。它的词（符号）语义模糊，才不得不发展出繁复的语法去兜底：not all 靠位置表示部分否定，none 表示全部否定，试图用词序弥补符号组合的歧义。可这治标不治本，英语法律文书的语法繁复到极点，照样天天打官司——语法从来没有真正消灭过语义歧义。&lt;/p&gt;
&lt;p&gt;现在再看汉语的语法，发现他实际上和数学如出一辙。句子的意思由句子用了哪些字决定，而不是用了哪些语法决定。&lt;/p&gt;
&lt;p&gt;所谓精确，是先把概念、关系、定义想清楚，形式只是跟着语义走。语法完整、连接词齐全，制造的只是一种&amp;quot;看起来很精确&amp;quot;的假象。&lt;/p&gt;
&lt;h1 id=&#34;数字符号是表意的&#34;&gt;数字符号是表意的&lt;/h1&gt;
&lt;p&gt;那数学符号到底是什么东西？我的结论是：&lt;strong&gt;数学符号本质上就是简化字。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;+&lt;/code&gt; 不承载任何读音，它直接携带&amp;quot;加&amp;quot;的语义；&lt;code&gt;÷&lt;/code&gt; 直接是&amp;quot;除&amp;quot;，&lt;code&gt;=&lt;/code&gt; 直接是&amp;quot;等于&amp;quot;，&lt;code&gt;∴&lt;/code&gt; 直接是&amp;quot;所以&amp;quot;，&lt;code&gt;∀&lt;/code&gt; 是&amp;quot;任意&amp;quot;，&lt;code&gt;∃&lt;/code&gt; 是&amp;quot;存在&amp;quot;。字形绕过声音，直接绑定意义——这和&amp;quot;水&amp;quot;这个字直接携带水的语义，没有任何结构上的区别。而且它们比汉字走得更远：核心符号只有几十个，一个符号只对应一个意义，没有多义，没有歧义。这是一种被设计成&amp;quot;低学习成本、高表意效率&amp;quot;的极限简化字。连公式里的字母 a、b、x 都被去拼音化了，它们不再表音，只是&amp;quot;甲、乙、丙&amp;quot;式的占位符。&lt;/p&gt;</description>
    </item>
    <item>
      <title>小妾心态</title>
      <link>https://microcai.org/2026/09/26/xiaoqie-xingtai.html</link>
      <pubDate>Sat, 26 Sep 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/09/26/xiaoqie-xingtai.html</guid>
      <description>&lt;p&gt;从公司、学校到学术圈，不少中国人面对洋人，腰是弯的。他们把洋人的认可当成唯一真实的认可：洋人夸一句，才算真的夸；洋人批评一句，立刻自我怀疑；同胞的夸奖，反倒不作数。&lt;/p&gt;
&lt;p&gt;我管这叫小妾心态：要的不是平等交流，是临幸。&lt;/p&gt;
&lt;h2 id=&#34;几个标本&#34;&gt;几个标本&lt;/h2&gt;
&lt;p&gt;DeepSeek，论文只发 arXiv，开源只对英文世界。我在他们开源页面提意见，得到的回复是：不用英文，洋人看不懂。&lt;/p&gt;
&lt;p&gt;阿里千问更进一层。中文页面只字不提怎么获取开源成果，英文页面倒有手把手教程，教你下载权重、自己训练。我在他们 GitHub 仓库里用中文讨论，直接被英文回复：不欢迎任何中文讨论。&lt;/p&gt;
&lt;p&gt;Manus，在北京开发布会，全程英语。官网全英文且拒绝中国 IP，高管明说没有中文版计划，总部随后迁去新加坡。后来卖给 Meta，官方声明说，被收购是对我们工作的&amp;quot;认可&amp;quot;——这笔交易在 2026 年 4 月被监管部门依法叫停，Manus 恢复了独立运营。渴望册封的，连册封都没能完成。&lt;/p&gt;
&lt;p&gt;长城魏建军，中国汽车产销量全球第一的当下，还在年会上说&amp;quot;距离那些优秀的公司差距还非常大&amp;quot;，要&amp;quot;谦虚地向欧美日韩学习&amp;quot;。&lt;/p&gt;
&lt;p&gt;学校也没闲着。到现在还有大量学校搞全英文授课，连数学课都用英语上。老师累，学生累，但看表演的很开心。这个怪现象，后面单独拆。&lt;/p&gt;
&lt;p&gt;对照组也有三个。&lt;/p&gt;
&lt;p&gt;龙芯，中文文档是权威版本，英文版是&amp;quot;为了方便不懂汉语的人&amp;quot;的翻译。洋人批评英文文档更新不足，龙芯不接这个茬：那是你的问题，不是我的优先级问题。&lt;/p&gt;
&lt;p&gt;德国大众，ID 系列被德国人批评&amp;quot;优先中国市场&amp;quot;。大众没装死，立刻调整。改没改好是能力问题，改不改是态度问题。&lt;/p&gt;
&lt;p&gt;中国空间站，操作界面全是汉字。外国宇航员想上去，先学汉语。西方媒体骂&amp;quot;不国际化&amp;quot;，国内也有一群人跟着骂&amp;quot;不合群&amp;quot;，甚至阴阳怪气说&amp;quot;设计人员英语不行&amp;quot;。&lt;/p&gt;
&lt;h2 id=&#34;分界线不在用不用英文&#34;&gt;分界线不在用不用英文&lt;/h2&gt;
&lt;p&gt;用英文本身没有错。美国公司英文优先，没人说它崇英；法国公司法文优先，德国公司德文优先。母语优先，外加通用语红利，这是国际通行的默认规则。龙芯中文优先，逻辑上和苹果英文优先完全对称。&lt;/p&gt;
&lt;p&gt;分界线在三个问题上：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;把外部认可当不当成唯一认可；&lt;/li&gt;
&lt;li&gt;把本国用户当不当成二等受众；&lt;/li&gt;
&lt;li&gt;被本国用户批评之后，是调整优先级，还是拿&amp;quot;洋人看不懂&amp;quot;来辩护。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;三条全中的，被批评就不冤。&lt;/p&gt;
&lt;p&gt;大众被批评后改了，所以它顶多是能力问题。DeepSeek 说&amp;quot;洋人看不懂&amp;quot;，是把解释框架外包了——&amp;ldquo;洋人看不看得懂&amp;quot;是必须解决的问题，&amp;ldquo;中国人看不看得懂&amp;quot;就不配优先。阿里那句&amp;quot;不欢迎任何中文讨论&amp;rdquo;，则是从&amp;quot;让你等翻译&amp;quot;升级成&amp;quot;让你闭嘴&amp;rdquo;。这已经不是优先级倒置，是投名状：为了向中心表忠，主动清理母语社区。&lt;/p&gt;
&lt;h2 id=&#34;小妾想争的其实是册封&#34;&gt;小妾想争的其实是册封&lt;/h2&gt;
&lt;p&gt;小妾心态这个说法，其实还不够准确。&lt;/p&gt;
&lt;p&gt;小妾争宠是被动的，等的是临幸。DeepSeek 们不是被动等，是主动抢——抢的是中心席位。更准确的诊断叫&amp;quot;中心承认焦虑&amp;quot;：边缘者想被中心册封，于是把中心的标准内化成自己的最高标准。&lt;/p&gt;
&lt;p&gt;而&amp;quot;洋人之下我第一&amp;quot;是一种依附性优越感。它的等级是：洋人 &amp;gt; 我 &amp;gt; 同胞。我不要爬到洋人头上，我要的是在洋人之下当第一，在同胞之上当例外。当年的买办就是这么吃饭的。这种自傲是借来的，所以它脆弱，需要不断确认&amp;quot;洋人还在看我&amp;quot;，甚至需要比洋人更积极地排斥中文，来证明自己配得上那个圈子。&lt;/p&gt;
&lt;p&gt;阿里那句&amp;quot;不欢迎任何中文讨论&amp;quot;，就是这个心理的完整标本。&lt;/p&gt;
&lt;h2 id=&#34;友邦惊诧论九十五年没变&#34;&gt;友邦惊诧论，九十五年没变&lt;/h2&gt;
&lt;p&gt;这个心态有名字。1931 年鲁迅就骂过：友邦惊诧论。&lt;/p&gt;
&lt;p&gt;九一八之后学生赴京请愿抗日，国民政府通电说&amp;quot;友邦人士，莫名惊诧，长此以往，国将不国&amp;quot;。鲁迅往死里打：日本人占东三省、枪毙人民，友邦不惊诧；学生请愿有一点纷扰，友邦就惊诧了。把外国人的情绪反应当成约束本国人的最高准则，这就是奴性。&lt;/p&gt;
&lt;p&gt;九十五年过去，外壳换了，内核没换。变的只是主体：1931 年是政治当局在执行友邦惊诧论，今天是资本在执行。DeepSeek 说&amp;quot;洋人看不懂&amp;quot;，阿里说&amp;quot;不欢迎中文&amp;quot;，Manus 用英语开发布会，魏建军摆学生姿态——没有通电，没有警察，但外部中心的评价标准，同样被内化成安排自己人尊卑的最高裁决。&lt;/p&gt;
&lt;p&gt;国民党为什么是反动派？不是因为它弯腰的姿势难看，而是它的政权基础在外部中心手里——合法性、军援、财政都靠洋人，所以它必然替友邦执法。反动是病根，友邦惊诧论是症状。&lt;/p&gt;
&lt;h2 id=&#34;政治主权解决了评价主权还没有&#34;&gt;政治主权解决了，评价主权还没有&lt;/h2&gt;
&lt;p&gt;空间站为什么敢全中文？因为它不在别人的体系里运行：没有外国股东，不上市，不需要西方期刊盖章。它的&amp;quot;好&amp;quot;由中国的航天任务定义，外部认可只是锦上添花。它的中文优先，是政治主权完整加评价体系自主的产物。&lt;/p&gt;
&lt;p&gt;而国民经济的主体——公司、资本、市场——生存条件还嵌在外部中心主导的体系里：融资靠美元基金，退出靠纳斯达克或者卖给美国巨头，学术评价看 arXiv 和英文顶会，生态在 GitHub。它们的&amp;quot;好&amp;quot;还需要别人盖章，腰自然直不起来。&lt;/p&gt;
&lt;p&gt;所以这条分界线画得很清楚：谁的&amp;quot;好&amp;quot;需要外部盖章，谁就必然渴望临幸。国民党倒台快八十年了，买办阶级也消灭了，但这套心态还在——因为政治主权 1949 年就解决了，评价主权至今还在拉锯。&lt;/p&gt;
&lt;p&gt;不过这只解释了一半。&lt;/p&gt;
&lt;h2 id=&#34;心态比结构更顽固&#34;&gt;心态比结构更顽固&lt;/h2&gt;
&lt;p&gt;另一半是：有些人弯腰，不是因为靠洋人吃饭，而是膝盖已经弯惯了。&lt;/p&gt;
&lt;p&gt;批评空间站&amp;quot;不国际化&amp;quot;的那批国内网友，不靠 NASA 吃饭，不拿美元基金，弯腰没有任何生存压力——纯粹是心态内化。更讽刺的是，国内批评者用的词，和 Quora 上洋人的问句几乎一字不差：外部中心的规训，被原封不动搬进来当了自我审判。&lt;/p&gt;
&lt;p&gt;因为这套心态有自己的再生产线：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;教育：英语是&amp;quot;素质&amp;quot;的核心指标，英文好等于能力强，汉语好等于&amp;quot;只会应试&amp;quot;；&lt;/li&gt;
&lt;li&gt;媒体：诺贝尔、奥斯卡、西方榜单是默认的最高认可；&lt;/li&gt;
&lt;li&gt;学术：SSCI 和英文顶会决定职称，中文期刊次一等；&lt;/li&gt;
&lt;li&gt;家庭：送孩子出国、拿外国身份，是成功的标志。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;一个人从小被这条生产线加工，哪怕进了完全自主的体系，默认反应还是&amp;quot;英文才国际化&amp;quot;。&lt;/p&gt;</description>
    </item>
    <item>
      <title>数学就是几何，高数就是高维几何</title>
      <link>https://microcai.org/2026/09/25/math-is-gihe.html</link>
      <pubDate>Fri, 25 Sep 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/09/25/math-is-gihe.html</guid>
      <description>&lt;p&gt;我总觉得 alpha-beta 这种正交的波形，不如三相的波形好看。&lt;/p&gt;
&lt;p&gt;三个正弦波互差 120 度，彼此交织，像一条编好的辫子，任何时刻三个之和为零，波峰波谷均匀分布，怎么看怎么舒服。而 alpha-beta 只有两个波，一个到峰值另一个刚好过零，线条少，交织弱，单薄。&lt;/p&gt;
&lt;p&gt;后来我想明白了，这不是我的审美有问题。三相波形是物理世界本来的样子，旋转磁场就在那里转着；alpha-beta 是数学拆解之后的产物。所以我一直讨厌 Clarke 变换——它把好看的波形变丑了。&lt;/p&gt;
&lt;h1 id=&#34;一clarke-变换的真面目一次正交投影&#34;&gt;一、Clarke 变换的真面目：一次正交投影&lt;/h1&gt;
&lt;p&gt;先说结论：Clarke 变换不该叫 Clarke 变换，它该叫&lt;strong&gt;正交投影&lt;/strong&gt;。Park 变换也不该叫 Park 变换，它该叫&lt;strong&gt;旋转变换&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;为什么？看几何图像。[Ia, Ib, Ic] 三个电流，看起来是三维的。但只要没有零线，基尔霍夫电流定律决定了 Ia + Ib + Ic = 0，这个点在三维空间里的运动轨迹，永远被压在一个过原点的平面上。所谓 Clarke 变换，就是把三维空间里这个被约束的向量，沿平面法线 [1,1,1] 的方向&amp;quot;拍扁&amp;quot;到那个平面上，换用两个互相垂直的轴来表示。&lt;/p&gt;
&lt;p&gt;拍扁之后没有第三维泄露——这就是高维数学里标准的&lt;strong&gt;正交投影&lt;/strong&gt;。投影方向垂直于平面，被扔掉的零序分量和留下来的 α-β 分量在空间里严格垂直，谁也不会漏进谁。斜投影就做不到，零序会斜着漏进来，波形失真。&lt;/p&gt;
&lt;p&gt;Park 变换更简单：在二维平面内，把静止的坐标系旋转到跟着转子跑。静止观察者眼中的正弦波，在随动观察者眼中就是两个安静的直流量。它就是个旋转，叫&amp;quot;旋转变换&amp;quot;名实相符。&lt;/p&gt;
&lt;p&gt;用人名命名是很糟糕的做法。虽然起到了纪念某个人的作用，但带来的问题很多。万有引力定律里还没有牛顿的名字呢，咋了？大家就记不住牛顿了吗？我们记得牛顿，是因为他提出了万有引力，不是因为它叫&amp;quot;牛顿定律&amp;quot;。&amp;ldquo;正交投影&amp;quot;四个字本身就是知识点——幂等、无泄露、降维；&amp;ldquo;Clarke&amp;quot;三个字什么都没说，你只能去背那个带 2/3 系数的矩阵。&lt;/p&gt;
&lt;p&gt;命名需要对现象进行精辟的总结。这个话题我之前写过两篇：&lt;a href=&#34;https://microcai.org/2026/01/01/clarke-park-is-useless/&#34;&gt;Clarke-park 变换毫无意义&lt;/a&gt; 和 &lt;a href=&#34;https://microcai.org/2026/09/23/Acronym-is-for-idiots/&#34;&gt;无能配用首字母缩写&lt;/a&gt;，这里不展开。&lt;/p&gt;
&lt;h1 id=&#34;二教科书上的-clarke其实是三个东西&#34;&gt;二、教科书上的 Clarke，其实是三个东西&lt;/h1&gt;
&lt;p&gt;真正有意思的是：教科书上统统叫&amp;quot;Clarke 变换&amp;quot;的东西，根本不是一个东西，而是&lt;strong&gt;三个完全不同的数学操作&lt;/strong&gt;，仅仅因为长得像就被塞进了同一个人名底下。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;1. 两相采样（无零线）：2x2 基底变换。&lt;/strong&gt; 只装两个电流传感器，测 Ia 和 Ib，Ic = -Ia - Ib 不独立。采样数 = 2，空间秩 = 2，用 2x2 方阵。几何动作是&amp;quot;扶正&amp;rdquo;：把互差 120 度的斜交基，旋成互差 90 度的正交基。可逆，无损。&lt;/p&gt;</description>
    </item>
    <item>
      <title>TOKEN的最佳翻译</title>
      <link>https://microcai.org/2026/09/24/good-translation-for-token.html</link>
      <pubDate>Thu, 24 Sep 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/09/24/good-translation-for-token.html</guid>
      <description>&lt;p&gt;大语言模型火了之后，&lt;code&gt;token&lt;/code&gt; 这个词无处不在，但它的中文译名一直没定下来。目前最流行的是「词元」。我不同意——它译错了方向。更准确的译法应该是「&lt;strong&gt;模型字&lt;/strong&gt;」，简称「&lt;strong&gt;字&lt;/strong&gt;」。&lt;/p&gt;
&lt;p&gt;为什么「词元」别扭、「模元」差在哪、为什么「模型字」更顺，下面分头说。&lt;/p&gt;
&lt;h2 id=&#34;一词元为什么别扭&#34;&gt;一、「词元」为什么别扭&lt;/h2&gt;
&lt;h3 id=&#34;1-词先把你带偏&#34;&gt;1. 「词」先把你带偏&lt;/h3&gt;
&lt;p&gt;token 不一定是词。它可能是半个词、多个词、一个空格、一个标点、一个 emoji、半个汉字。叫「词元」，外行第一反应是「词的单位」，但 token 根本不是按词切的。名字里带「词」，等于在术语层面就预设了它是词——那些最常被分词器切碎的 subword、标点、空格，全都被这个译名屏蔽掉了。&lt;/p&gt;
&lt;h3 id=&#34;2-元太抽象太漂浮&#34;&gt;2. 「元」太抽象、太漂浮&lt;/h3&gt;
&lt;p&gt;「元」在中文术语里经常表示「基本、最小、meta」：元素、单元、元数据、元语言、元宇宙。它没有具体形象。结果「词元」听起来像「词的某种抽象元素」，不直观。一个译名里最该具体的那部分（它到底是什么单位），恰恰是最含糊的。&lt;/p&gt;
&lt;h3 id=&#34;3-读音语感平&#34;&gt;3. 读音语感平&lt;/h3&gt;
&lt;p&gt;「词元」读 cí yuán，两个阳平，读起来平直，缺少重音收束。它也不像「字」那样能单用。你能说「这个词元」「那个词元」，但日常语感远不如「这个字」「那个字」。&lt;/p&gt;
&lt;h3 id=&#34;4-不能简称搭配也弱&#34;&gt;4. 不能简称，搭配也弱&lt;/h3&gt;
&lt;p&gt;「词元」既不能简称成「词」（「词」已经指 word），也不能简称成「元」（「元」太泛）。搭配起来也怪：词元窗口、词元嵌入、词元化、按词元计费……都有一股论文腔，不顺。&lt;/p&gt;
&lt;h3 id=&#34;5-和已有词法术语纠缠&#34;&gt;5. 和已有词法术语纠缠&lt;/h3&gt;
&lt;p&gt;词、词素、语素、词根、词缀、词位、分词、词向量——「词元」挤进这一堆里，容易混。token 本来就不是词法单位，却被塞进「词」字辈，生态位不对。&lt;/p&gt;
&lt;h2 id=&#34;二模元对了第一步卡在第二步&#34;&gt;二、「模元」对了第一步，卡在第二步&lt;/h2&gt;
&lt;p&gt;最近又冒出另一个译名：「模元」。它的提出者同样反对「词元」，这一脚踩得对——它把最误导人的「词」换成了「模」，切断了「token 是一个词」这个错误预设。这一步走对了。&lt;/p&gt;
&lt;p&gt;但它的思路还停在「元」上。把「词」换成「模」，只是修好了错的那半截，虚的那半截原样留着：「元」还是那个漂浮、没有具体形象、不指向任何东西的尾巴。&lt;/p&gt;
&lt;p&gt;更要命的是，「模元」没法简称，而没法简称就没法构词。「模型字」能简称成「字」，一整个术语族就顺理成章地铺开了：&lt;/p&gt;
&lt;p&gt;简称“模”：会和模型、模态、模块、模板全撞；&lt;/p&gt;
&lt;p&gt;简称“元”：元数据、元学习、单元、元素，太泛；&lt;/p&gt;
&lt;p&gt;不简称：模元窗口、模元嵌入、模元化、多模元预测，能用，但长且生硬；“多模元”还很容易被读成“多模态”相关。&lt;/p&gt;
&lt;p&gt;相比之下，“模型字”可以落到“字”，于是有字窗口、字嵌入、字化、字级、下一字预测、多字预测。这种构词能力在技术传播里是实打实的优势，不是修辞上的顺口而已。术语的能产性——能不能拆出一个短词根去生成新词——往往比术语本身的长度更重要。“模元”是一个封闭的双字整体，拆不开；而“模型字”的“字”可以反复复用。&lt;/p&gt;
&lt;p&gt;这两个是 LLM 里最核心的技术术语。「下一字预测」顺口且准确——模型本来就是在预测下一个「字」；「多字预测」同理。换到「模元」上，你只能憋出「下一模元」「多模元」，又长又拗口；想简称成「元」，就成了「下一元预测」，丢了「模」，而且「多元预测」还会和统计里的「多元（multivariate）」撞车。换到「词元」更惨，「下一词」直接把人引回「词」的层面。&lt;/p&gt;
&lt;p&gt;所以「模元」比「词元」好一点，但它卡在同一个地方：把一个没法简称、没法构词的字，放在了一个最需要构词的位置上。&lt;/p&gt;
&lt;h2 id=&#34;三模型字为什么更顺&#34;&gt;三、「模型字」为什么更顺&lt;/h2&gt;
&lt;h3 id=&#34;1-结构自然&#34;&gt;1. 结构自然&lt;/h3&gt;
&lt;p&gt;「模型」限定，「字」作中心语：模型字 = 模型自己的字。这是汉语最熟悉的名词构造。&lt;/p&gt;
&lt;h3 id=&#34;2-字本来就不是汉字的专利&#34;&gt;2. 「字」本来就不是汉字的专利&lt;/h3&gt;
&lt;p&gt;这是整件事的关键。谁说「字」就一定得是汉字？&lt;/p&gt;
&lt;p&gt;计算机里早有现成的反例。CPU 的「字长」（word length）是它一次处理的数据宽度，「机器字」（machine word）是它眼里的基本单位——这些「字」和汉字八竿子打不着；「字节」（byte）也一样，带个「字」，却指 8 位数据单元。也就是说，中文「字」早就在计算机术语里占了坑，它的内核从来不是「书写字符」，而是「一个被识别、被计数、被处理的最小单位」。&lt;/p&gt;
&lt;p&gt;把这个内核套到大模型上，严丝合缝：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;CPU 一次处理一个字长；&lt;/li&gt;
&lt;li&gt;LLM 一次生成一个 token。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;两者在「按最小单位逐个处理」这件事上是同构的。区别只是：CPU 的字是硬件/指令集定义的固定位宽，模型的字是分词器/词表定义的离散符号——总而言之，都是「机器的字」，跟人类的「字 / 汉字」无关。&lt;/p&gt;
&lt;p&gt;大模型确实就是「一个字一个字」地往下写：每个 token 对应词表里的一个 ID，模型预测下一个 ID。至于它的一个字对应几个「人类的字」，那是另一个问题——就像 CPU 的字长是 32 位还是 64 位，跟汉字也没关系。所以模型字不是汉字，逻辑上完全接得上。&lt;/p&gt;</description>
    </item>
    <item>
      <title>无能配用首字母缩写</title>
      <link>https://microcai.org/2026/09/23/Acronym-is-for-idiots.html</link>
      <pubDate>Wed, 23 Sep 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/09/23/Acronym-is-for-idiots.html</guid>
      <description>&lt;p&gt;给新事物命名，从来都是一件吃力的事。它要求你把一个全新的东西揉碎了、看透了，抓住它最要紧的那几个核心特征，浓缩成一个别人一听就懂、一看就明的词。&lt;/p&gt;
&lt;p&gt;越是新的事物，越是难命名。因为越新，就越没有现成的词可以套用，越逼着你去动脑做真正的总结。&lt;/p&gt;
&lt;p&gt;而总结能力，是最见真章的能力。会不会命名，本质上是会不会抓本质。&lt;/p&gt;
&lt;h1 id=&#34;一命名的本质是总结&#34;&gt;一、命名的本质是总结&lt;/h1&gt;
&lt;p&gt;给新东西起名字，难在哪里？难在&amp;quot;总结&amp;quot;。你面对一个从未存在过的东西，脑子里没有现成答案。你必须回答两个问题：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;它到底是什么？&lt;/li&gt;
&lt;li&gt;它最核心的那个特征，怎么用几个字说清楚？&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;答不好第一个问题，名字就飘；答不好第二个问题，名字就长。一个真正的好名字，一定是把这两个问题都答对之后，自然涌出来的。&lt;/p&gt;
&lt;p&gt;汉语命名，走的就是这条路。看几个例子：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;火车&lt;/strong&gt;：有火（蒸汽）的车。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;飞机&lt;/strong&gt;：会飞的机器。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;电脑&lt;/strong&gt;：通电的脑子。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;手机&lt;/strong&gt;：拿在手里的机器。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;电视&lt;/strong&gt;：用电传过来的&amp;quot;视&amp;quot;（画面）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;互联网&lt;/strong&gt;：互相连起来的网。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;每一个，都是先总结出最核心的特征，再用已有的字拼出来。听到的人完全不需要查字典，一听就知道那是什么。这才是&amp;quot;命名&amp;quot;该有的样子。&lt;/p&gt;
&lt;h1 id=&#34;二首字母缩写是逃避总结&#34;&gt;二、首字母缩写是逃避总结&lt;/h1&gt;
&lt;p&gt;西方人在面对同样的问题时，拿出了另一套方案——首字母缩写。&lt;/p&gt;
&lt;p&gt;这套方案分两步，两步都巧妙地绕开了&amp;quot;总结&amp;quot;：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;第一步，堆名词。&lt;/strong&gt; 把一个新东西的所有特征，用一长串现成的名词罗列出来。注意，是罗列，不是总结。罗列是不需要动脑子的，只需要把描述性的词一个个往上垒。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;第二步，提首字母。&lt;/strong&gt; 把这串名词每个词的首字母拎出来，拼成一个新&amp;quot;词&amp;quot;。&lt;/p&gt;
&lt;p&gt;于是，命名这件事，就被&amp;quot;糊弄&amp;quot;过去了。你仔细看这两个步骤：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;罗列描述，是&lt;strong&gt;不敢总结&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;提取缩写，是&lt;strong&gt;放弃意义&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;两头加在一起，一个全新的东西，就在没有经过任何&amp;quot;本质提炼&amp;quot;的情况下，被&amp;quot;命名&amp;quot;了——或者说，被&amp;quot;略过命名&amp;quot;了。&lt;/p&gt;
&lt;p&gt;看看这些所谓的&amp;quot;名字&amp;quot;：&lt;/p&gt;
&lt;table&gt;
	&lt;thead&gt;
			&lt;tr&gt;
					&lt;th&gt;缩写&lt;/th&gt;
					&lt;th&gt;背后的描述&lt;/th&gt;
			&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
			&lt;tr&gt;
					&lt;td&gt;LASER&lt;/td&gt;
					&lt;td&gt;Light Amplification by Stimulated Emission of Radiation&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;RADAR&lt;/td&gt;
					&lt;td&gt;Radio Detection And Ranging&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;SCUBA&lt;/td&gt;
					&lt;td&gt;Self-Contained Underwater Breathing Apparatus&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;LED&lt;/td&gt;
					&lt;td&gt;Light-Emitting Diode&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;GPS&lt;/td&gt;
					&lt;td&gt;Global Positioning System&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;HTTP&lt;/td&gt;
					&lt;td&gt;HyperText Transfer Protocol&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;AIDS&lt;/td&gt;
					&lt;td&gt;Acquired Immune Deficiency Syndrome&lt;/td&gt;
			&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;看出来了吗？它们没有一个是&amp;quot;名字&amp;quot;。它们只是&amp;quot;一长串描述&amp;quot;被折叠之后的&lt;strong&gt;索引&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;首字母并没有替它总结——首字母只是替它&lt;strong&gt;略过&lt;/strong&gt;了总结这一步。&lt;/p&gt;
&lt;p&gt;当你第一次看到 LASER 这个词，你能从中读出任何信息吗？不能。你读出的只是四个字母 L-A-S-E-R。它背后到底是个什么东西，你得翻开那串长长的形容短语才知道。也就是说，这个名字，对第一次听到它的人而言，是&lt;strong&gt;空的&lt;/strong&gt;。&lt;/p&gt;</description>
    </item>
    <item>
      <title>大臣求情是私利</title>
      <link>https://microcai.org/2026/08/14/plead-for-personal-gain.html</link>
      <pubDate>Fri, 14 Aug 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/08/14/plead-for-personal-gain.html</guid>
      <description>&lt;p&gt;古时候，皇帝经常有嚣张的儿子犯了罪。&lt;/p&gt;
&lt;p&gt;东窗事发了，被百姓告到御前了。皇帝把犯罪的儿子拿下了，下狱了。&lt;/p&gt;
&lt;p&gt;然后，就轮到百官表演了。&lt;/p&gt;
&lt;p&gt;百官会轮番陈请，要求皇帝宽宏大量。理由不外乎“虎毒不食子”。&lt;/p&gt;
&lt;p&gt;皇帝便勉为其难地，赦免了儿子的死罪。&lt;/p&gt;
&lt;p&gt;以前我觉得是大臣演戏，配合皇帝。皇帝本来就想保下儿子。&lt;/p&gt;
&lt;p&gt;后来我才发现，事情并没有那么简单。&lt;/p&gt;
&lt;p&gt;不管皇帝本人想不想保下儿子，他都必须保。&lt;/p&gt;
&lt;p&gt;我们分析皇帝两种行为及其结果。&lt;/p&gt;
&lt;h4 id=&#34;皇帝法外开恩饶过了儿子那以后大臣犯了同样的罪要不要饶恕呢&#34;&gt;皇帝法外开恩饶过了儿子，那以后大臣犯了同样的罪，要不要饶恕呢？&lt;/h4&gt;
&lt;p&gt;如果皇帝不饶恕大臣，那么他就犯了“双标”的错。虽然表面上大臣并不能强迫皇帝必须遵守统一标准。&lt;/p&gt;
&lt;p&gt;但是，皇帝的&lt;strong&gt;名声&lt;/strong&gt;可就&lt;strong&gt;臭了&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;皇帝&lt;strong&gt;名声臭了，队伍就不好带了。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;如果皇帝宽恕了大臣，那就从制度上形成了违法免罪的效果了。
长此以往，国家就烂了。&lt;/p&gt;
&lt;h4 id=&#34;皇帝如果坚持大义灭亲呢&#34;&gt;皇帝如果坚持大义灭亲呢？&lt;/h4&gt;
&lt;p&gt;这对那些想贪污的大臣来说，可就难受了。意味着他们日后的一切贪腐都逃不了制裁。&lt;/p&gt;
&lt;p&gt;而那些不想犯罪的大臣就舒服了？ 并不。清流们会批评皇帝 &lt;strong&gt;冷血&lt;/strong&gt;，连儿子都能杀，那杀大臣更不可能心慈手软。独夫的标签就贴上了，&lt;strong&gt;名声同样臭了&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;所以，皇帝不论怎么做，都是错的。&lt;/p&gt;
&lt;p&gt;想破局，就得未雨绸缪。不能等儿子犯罪了才想怎么办。而是一开始就要好好的进行教育。防患于未然。&lt;/p&gt;
&lt;p&gt;如果皇帝真的这么想，那又天真了。&lt;/p&gt;
&lt;p&gt;因为，大臣早就准备好了另一套说辞，曰：“二龙不相见”。&lt;/p&gt;
&lt;h4 id=&#34;二龙不相见的本质是大臣要垄断皇子的教育权&#34;&gt;二龙不相见的本质，是大臣要垄断皇子的教育权&lt;/h4&gt;
&lt;p&gt;如果皇子不听大臣的话，大臣就挑拨离间。挑拨离间的方法那可是多种多样。
毕竟父子不相见了，就难免产生隔阂。有嫌隙的人，最受不了外人的挑拨。&lt;/p&gt;
&lt;p&gt;如果皇子非常乖，很听大臣的话呢？&lt;/p&gt;
&lt;p&gt;大臣是开心了，皇帝该不舒服了。毕竟，谁愿意把祖宗基业，交给一个受外人摆布的人呢？
皇帝不舒服了，做儿子的，就只能赌一把了。造反的太子莫不如是。&lt;/p&gt;
&lt;p&gt;所以，皇帝的后宫要是女人少了，大臣也会劝皇帝要开枝散叶。核心逻辑也是一样的。
皇帝不玩女人了，那那些娶18房姨太太的大臣咋办？你的女人比皇帝还多怎么得了。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;所以，只有带头堕落的皇帝，才是百官眼里的好皇帝。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;拜登这种不顾法律、不顾脸面，也要死保儿子的总统，真可谓是打着灯笼都找不着的“好总统”啊。
毕竟只有拜登不要脸了，史密斯们才能更加不要脸。&lt;/p&gt;</description>
    </item>
    <item>
      <title>重新定义自动驾驶等级</title>
      <link>https://microcai.org/2026/08/14/redefine-autopilot.html</link>
      <pubDate>Fri, 14 Aug 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/08/14/redefine-autopilot.html</guid>
      <description>&lt;p&gt;最近看修仙动画片，发现主角修行功法的时候，对功法修炼的掌握程度，使用的不是数字 lv1 lv2 这种表示，而是使用一系列的四字成语。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;初窥门径 登堂入室 融会贯通 游刃有余 炉火纯青 登峰造极 出神入化 超凡脱俗 返璞归真&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这种描述等级的方式，非常有意境，形容得很贴切。比冷冰冰的数字表示好多了。&lt;/p&gt;
&lt;p&gt;我突然发现，洋人在该用数字的地方不用数字，不该用数字的地方反而用了数字。&lt;/p&gt;
&lt;p&gt;比如月份，这种该用数字的非要装逼用12个名字。
等级划分反而用了毫无意境的数字。&lt;/p&gt;
&lt;p&gt;等级划分？ 对，突然想到了汽车的自动驾驶。&lt;/p&gt;
&lt;p&gt;洋人给自动驾驶划分了5个等级，在我看来，是一种拍脑袋想出来的划分。&lt;/p&gt;
&lt;p&gt;在我看来，自动驾驶的等级应该是这样的：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;车距保持：自动驾驶的起点，从定速巡航升级而来。我认为车距保持是自动驾驶的起点，是因为车距保持需要雷达探测前车的距离。也就是说，需要外界感知。解放了双脚。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;车道保持：除了感知前车自动跟车，还能感知车道，自动把车辆保持在车道内。解放了双手。感知的内容比上一个等级变更多了。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;高速领航：在前两个能力的基础上进行进一步升级，能在高速这种封闭道路里实现了自动驾驶。虽然下高速后还得人开，但是已经能大幅解放人类了。需要的感知更多了，增加了视觉感知。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;市区通勤：算法更完善，不仅仅能实现在封闭道路自动驾驶，还能在城区道路自动驾驶。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;无人驾驶：算法进步的终极阶段，就是彻底的无需人类干预了。车子可以实现无人驾驶了。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;用我这套定义为何比洋人的定义更好呢？&lt;/p&gt;
&lt;p&gt;首先，等级和能实现的功能非常明确！
其次，名词自解释。&lt;/p&gt;
&lt;p&gt;作为对比，洋人的 lv1 lv2 这种标记，根本不知道到底表达了什么。&lt;/p&gt;
&lt;p&gt;那么 SAE 的等级定义到底错在哪里？我仔细想想，主要有三点致命缺陷。&lt;/p&gt;
&lt;p&gt;第一点，SAE 的等级定义&lt;strong&gt;完全没有可感知性&lt;/strong&gt;。你去看 SAE 的 J3016 标准文档，Level 1 是什么，Level 2 又是什么？你得去翻手册。Level 2 说&amp;quot;部分驾驶自动化&amp;quot;，可&amp;quot;部分&amp;quot;到底是指能控制方向盘还是能控制油门刹车？完全不知道。反观我的定义，从名字就能知道这级车能干嘛：车距保持、车道保持、高速领航、市区通勤、无人驾驶，一看就懂，一目了然。&lt;/p&gt;
&lt;p&gt;第二点，SAE 的等级划分&lt;strong&gt;割裂了技术能力与功能实现&lt;/strong&gt;。SAE 的 Level 2 和 Level 3 之间，差别仅仅是&amp;quot;是否需要人类随时接管&amp;quot;，而不是&amp;quot;车辆能做什么&amp;quot;。一个能在高速上自动驾驶的 Level 2 车，和一个在高速上自动驾驶的 Level 3 车，它们能感知和决策的能力是几乎一样的——唯一的区别是，Level 3 的车能自己处理驾驶任务，而 Level 2 的车不行。这根本不是&amp;quot;能力等级&amp;quot;，而是&amp;quot;责任划分&amp;quot;。把&amp;quot;人类该负责什么&amp;quot;混进&amp;quot;车辆能做什么&amp;quot;的等级里，本身就违背了等级命名的初衷。等级命名应该描述的是&amp;quot;这辆车能干到什么程度&amp;quot;，而不是&amp;quot;出了事故谁背锅&amp;quot;。我的定义里，每一级都对应一个清晰的能力跃迁：从只能跟车，到能跟车还能车道保持，到能在高速领航，到能在市区通勤，最后到完全无人。每一步都是实打实的功能增强，而不是责任推诿的借口。&lt;/p&gt;
&lt;p&gt;第三点，SAE 的等级&lt;strong&gt;对消费者毫无帮助&lt;/strong&gt;。当你去买车的时候，销售说&amp;quot;这车是 Level 2，有自适应巡航和车道保持&amp;quot;，你根本不知道它到底能帮你做什么。Level 2 到底能帮你导航吗？能帮你自动泊车吗？能帮你过红绿灯吗？完全不知道。而如果我告诉你，这是&amp;quot;高速领航&amp;quot;等级的车，你就能立刻明白：这车可以在高速上自动驾驶，帮你自动变道、自动上下匝道。如果是&amp;quot;市区通勤&amp;quot;等级的车，你就能明白：这车还能在市区里自己跑。等级命名直接描述了产品的功能卖点，这才是消费者真正关心的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>A New Taxonomy of Language</title>
      <link>https://microcai.org/2026/07/30/new-lang-category-en.html</link>
      <pubDate>Thu, 30 Jul 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/07/30/new-lang-category-en.html</guid>
      <description>&lt;p&gt;The old classification of language families, built on assumptions of blood ties, geographic proximity, and human migration, is fundamentally flawed. As globalization deepens and linguistic research advances, this approach exposes a critical gap—it ignores the core mechanism of human language processing: the brain&amp;rsquo;s acoustic decoding strategies.&lt;/p&gt;
&lt;p&gt;We must therefore construct an entirely new taxonomy of language, one centered on syllable structure and the brain&amp;rsquo;s parsing mechanisms.&lt;/p&gt;
&lt;p&gt;Let me explain step by step.&lt;/p&gt;</description>
    </item>
    <item>
      <title>新语言分类学</title>
      <link>https://microcai.org/2026/07/30/new-lang-category.html</link>
      <pubDate>Thu, 30 Jul 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/07/30/new-lang-category.html</guid>
      <description>&lt;p&gt;旧有的语系分类，建立在血缘地缘和人口迁徙的假设之上。然而随着全球化和语言学研究的深入，这种分类法暴露出根本性的缺陷：它忽视了人类语言处理的核心机制——大脑的声学解码策略。&lt;/p&gt;
&lt;p&gt;因此，我们必须建立一种全新的语系分类体系：以音节结构和大脑解析方式为核心标准。&lt;/p&gt;
&lt;p&gt;且听我细细道来。&lt;/p&gt;
&lt;h1 id=&#34;一音节结构大脑解码的起点&#34;&gt;一、音节结构：大脑解码的起点&lt;/h1&gt;
&lt;p&gt;人类说话的声音并非连续流，而是被有节奏的间隔分割成一个个独立的音节。从声学物理的角度观察，每个音节的基本结构是统一的：以辅音（或半元音）起头，以元音或半元音收尾。单独一个元音或半元音，也完全可以自成音节。&lt;/p&gt;
&lt;p&gt;然而，耳朵听到的，并不是真实的音节结构。大脑还需要根据语义进行二次拆分。&lt;/p&gt;
&lt;p&gt;以 &lt;strong&gt;thank you&lt;/strong&gt; 为例。耳朵听到的，是 &lt;strong&gt;&amp;ldquo;三 Q&amp;rdquo;&lt;/strong&gt; 这两个音节。但大脑需要将其拆分成 &lt;em&gt;thank&lt;/em&gt; 和 &lt;em&gt;you&lt;/em&gt; 两个独立的意义单位。&lt;/p&gt;
&lt;p&gt;按意义边界重新切分后，音节的结构就出现了分化——&lt;strong&gt;开音节&lt;/strong&gt;与&lt;strong&gt;闭音节&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;em&gt;thank&lt;/em&gt; 以辅音 &lt;strong&gt;k&lt;/strong&gt; 收尾，是典型的&lt;strong&gt;闭音节&lt;/strong&gt;（结尾封闭）。&lt;/li&gt;
&lt;li&gt;&lt;em&gt;you&lt;/em&gt; 以元音收尾，是典型的&lt;strong&gt;开音节&lt;/strong&gt;（结尾开放）。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;世界上有些语言根本不允许闭音节的存在。汉语、日语、意大利语就是典型：它们所有的音节都必须以元音或半元音收尾。&lt;/p&gt;
&lt;p&gt;而另一些语言则大量充斥闭音节单词。英语、德语、阿拉伯语和斯拉夫语就是代表。&lt;/p&gt;
&lt;p&gt;但这里有一个关键的物理事实：人的嘴巴无法单独发出纯辅音。因为辅音的声学信息，编码在声波的&lt;strong&gt;突变&lt;/strong&gt;——频率的突变里。而“突变”本质上就是瞬态现象，不可持续，是一瞬间的事件。相反，元音的信息编码在声波的&lt;strong&gt;基频和泛音&lt;/strong&gt;结构里，是一种可持续的声波。&lt;/p&gt;
&lt;p&gt;因此，从嘴巴发出的声音，必然是以元音（或半元音）收尾的。辅音丛可以出现在音节开头，但音节结尾必须是可发声的元音。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;补充说明&lt;/strong&gt;：在我的理论框架中，“能持续发声的就是元音”——那些只能短暂发出、不能持续发音的音就是辅音。其余不能归入纯粹辅音或元音的，也都是元音家族。能和任意辅音自由搭配的，称为&lt;strong&gt;纯元音&lt;/strong&gt;（如 &lt;em&gt;a&lt;/em&gt;，可组成 &lt;em&gt;ta&lt;/em&gt;、&lt;em&gt;fa&lt;/em&gt;、&lt;em&gt;ma&lt;/em&gt;、&lt;em&gt;la&lt;/em&gt;、&lt;em&gt;sa&lt;/em&gt; 等）。不能任意搭配的，就称为&lt;strong&gt;半元音&lt;/strong&gt;（如 &lt;em&gt;s&lt;/em&gt;，&lt;em&gt;ts&lt;/em&gt; 是很自然的音节，但 &lt;em&gt;fs&lt;/em&gt;、&lt;em&gt;ks&lt;/em&gt;、&lt;em&gt;ls&lt;/em&gt; 就很不自然）。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;现在我们可以重新审视之前听到的 &lt;em&gt;thank you&lt;/em&gt;（三 Q）这个例子。物理上，它被发成两个开音节（结尾都有元音），但在意义边界上，大脑把它切成了闭音节 &lt;em&gt;thank&lt;/em&gt;（辅音 k 结尾）和开音节 &lt;em&gt;you&lt;/em&gt;。&lt;/p&gt;
&lt;p&gt;现在，我们可以基于&lt;strong&gt;意义边界&lt;/strong&gt;与&lt;strong&gt;发音边界&lt;/strong&gt;的关系，将语言划分为两大基本类型：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;开音节语言&lt;/strong&gt;：大脑解析的语义切分点，与嘴巴发声音节的物理边界完全对齐。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;闭音节语言&lt;/strong&gt;：大脑解析的语义切分点，与嘴巴发声音节的物理边界不一致。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这个定义看似简单，但它触及了人类语言处理的核心差异。&lt;/p&gt;
&lt;p&gt;闭音节语言之所以需要额外的处理，就是因为其语义切分点与发音物理边界不重合。这意味着大脑必须执行&lt;strong&gt;音节回溯重组&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;让我们对比两种语言的解码机制：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;开音节语言（如汉语）&lt;/strong&gt;——大脑的解码器是&lt;strong&gt;帧同步&lt;/strong&gt;的：我听到一个音节（拍子），就直接映射一个独立的意义。整个处理流程是线性的、确定性的，就像流水线上的节拍器，一拍一个词。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;闭音节语言（如英语）&lt;/strong&gt;——大脑的解码器必须内置一套&lt;strong&gt;回溯重组算法&lt;/strong&gt;：&lt;/p&gt;
&lt;p&gt;听到 &lt;em&gt;&amp;ldquo;te-napples&amp;rdquo;&lt;/em&gt; 这个声学序列（物理帧边界在 &lt;em&gt;te&lt;/em&gt; 和 &lt;em&gt;napples&lt;/em&gt; 之间）。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;发音连读：ten apples 重组为 te na ples 三个音节&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/assets/images/syllable-connected-speech.jpg&#34;&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;大脑判断：当前的物理帧切分位置似乎不对，需要调整。&lt;/li&gt;
&lt;li&gt;大脑检索上下文：已知 &lt;em&gt;ten&lt;/em&gt; 是数词，&lt;em&gt;apples&lt;/em&gt; 是名词。&lt;/li&gt;
&lt;li&gt;大脑执行重组：把 &lt;em&gt;n&lt;/em&gt; 从后一个帧“夺回”，归还给前一个帧，最终还原为 &lt;em&gt;&amp;ldquo;ten apples&amp;rdquo;&lt;/em&gt;。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;img alt=&#34;听觉重组：大脑将 te na ples 回溯还原为 ten apples&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/assets/images/syllable-auditory-recombination.jpg&#34;&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>以同行评议为基石、以期刊等级为货币的体系，已经死了</title>
      <link>https://microcai.org/2026/07/29/sci-is-dead.html</link>
      <pubDate>Wed, 29 Jul 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/07/29/sci-is-dead.html</guid>
      <description>&lt;p&gt;SCI 体系已经死了。以同行评议为基石、以期刊等级为货币，早就异化为科学创新的系统性阻碍。它不再是发现真理的竞技场，而是维护既得利益的官僚市场。&lt;/p&gt;
&lt;h1 id=&#34;对学术圈内部人士的罪恶&#34;&gt;对学术圈内部人士的罪恶&lt;/h1&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;有罪推定
对颠覆性创新的原则：有罪，直到被证明清白。一个挑战主流范式的想法，必须取悦两三个匿名的审稿人——大概率是现有体系的捍卫者。这不是同行评议，这是守门人的审判。原创思想最脆弱的婴儿期，直接就被这个体系的第一个门槛绞杀。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;奖励安全平庸，惩罚危险天才
科学发现异化为指标游戏。驯化科学家成为精明的论文商人，而不是不顾一切的真理探险家。一个大问题拆成五篇灌水论文，比花五年啃一个可能失败的硬骨头，要“理性”得多。短期、可量化、安全的产出，系统性挤出长期、高不确定性、可能革命性的探索。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;影响因子成了目的本身
影响因子和顶刊本应是衡量成果的指标，却变成了成果本身。科学家不再问&amp;quot;我解决了什么问题&amp;quot;，而是问&amp;quot;这能发顶刊吗？&amp;quot;。整个科研方向被商业出版集团的盈利需求扭曲。热点扎堆，冷门绝迹。科学发现的方向，被外包给了期刊编辑和审稿人。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;制造学阀和圈子的护城河
封闭的评审、封闭的引文网络、封闭的学术会议，人为制造只有内部人才能共享的资源和信用。非名校、非嫡系的局外人，颠覆性思想甚至没资格被看到，遑论被评价。这不是择优的精英制，这是基于出身的种姓制。学阀之所以为阀，就是这套体系给了他们阻碍流动的权力。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;摧毁好奇心，培养学术公务员
论文发表背后的驱动力不是“我想搞明白”，而是“我需要发表才能生存”。奖励算计，惩罚天真。诱导人们在数据上做微小的修饰，在引文上搞审稿人的小圈子互惠。不是在培养探索者，是在培养学术公务员。这种精神层面的系统性摧残，是最大也最隐蔽的损失。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h1 id=&#34;对公众的罪恶&#34;&gt;对公众的罪恶&lt;/h1&gt;
&lt;p&gt;付费墙是对公众知情权的制度性掠夺，罪恶三层：&lt;/p&gt;
&lt;p&gt;第一层：双重收费的合法化抢劫&lt;/p&gt;
&lt;p&gt;大多数由公共财政资助的研究，公众已经付过第一道钱。成果发表后，被商业出版集团据为己有，筑起天价付费墙。普通人想看自己纳税供养的研究，要再付 30-50 美元——一周菜钱。同一件东西付两次费：第一次供养研究，第二次阅读结果。这不是商业模式，是拦路抢劫。&lt;/p&gt;
&lt;p&gt;第二层：公共知识的技术性阉割&lt;/p&gt;
&lt;p&gt;付费墙制造荒谬：最重要的公共知识，在法理上属于全人类，在技术上却被锁在少数机构和富人的通道里。独立学者、高中理科教师、罕见病患者家属——他们的知情权被一堵墙否决。科学本应是照亮黑暗的公共火炬，却被付费墙变成了私人剧场。&lt;/p&gt;
&lt;p&gt;第三层：伪善的开放获取赎罪券&lt;/p&gt;
&lt;p&gt;文章处理费是这套体系发明的赎罪券。出版成本从读者端转移到作者端，每篇数千甚至上万美元。只有经费充裕的课题组才“买得起”开放获取。穷读者付不起阅读的钱，穷研究者付不起发表的钱。这没拆除付费墙，只是挪了个地方，并发明了新的盈利增长点。用“开放”的漂亮话，掩盖更深层的不平等。&lt;/p&gt;
&lt;p&gt;为什么这三条罪状致命？&lt;/p&gt;
&lt;p&gt;因为直接证明，“圈地自萌”和“拒绝公众监督”根本不是无意的副产品，而是精心维护的利益结构。&lt;/p&gt;
&lt;p&gt;“你们不懂，所以别来评价我。”
“就算你们想懂，也得先付钱。”
“付了钱之后，你们还是不懂，因为都是行业黑话。”&lt;/p&gt;
&lt;p&gt;认知门槛是第一道锁，付费墙是第二道锁，封闭的评审黑箱是第三道锁。三道锁锁死，出钱的公众被永久、结构性地隔绝在科学活动的所有环节之外。他们只剩下一项义务：继续交税供养，然后被告知“心怀敬畏，保持安静”。&lt;/p&gt;
&lt;h1 id=&#34;是果实高了还是体系在捣鬼&#34;&gt;是果实高了，还是体系在捣鬼？&lt;/h1&gt;
&lt;p&gt;“低垂的果实被摘完了”——描述的是客观难度上升。无可辩驳。不可能再像法拉第那样，用一个线圈和一块磁铁就发现电磁感应。&lt;/p&gt;
&lt;p&gt;但是，这套学术门阀体系，并非无辜地在这条曲线上运行。它的核心罪行，是让本已陡峭的曲线变得近乎垂直，并把攀登者的手脚都绑住了。&lt;/p&gt;
&lt;p&gt;不是因为果实高了所以进展慢。体系通过以下方式，系统性地扼杀了摘高处的能力：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;资源错配：本应用于制造高空作业平台的宝贵资源（资金和人才），大量浪费在“地面测绘”（灌水）和“军备竞赛”（追求指标）上。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;扼杀工具创新：真正的颠覆性想法就像发明飞机去摘果子，但在现有体系下，这种想法在图纸阶段就会被“地面摘果协会”的权威以“不靠谱、不懂重力”为由枪毙。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;摧毁士气：当最聪明的大脑都被规训为追求论文数量的“学术公务员”，而不是不顾一切的探险家，你还能指望谁去挑战困难问题？&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;“低垂果实论”是被利用的借口。它把由体制造成的人为失败，巧妙包装成不可抗拒的自然规律。&lt;/p&gt;
&lt;p&gt;“你看，不是评价体系不行，而是自然规律变难了。所以你们公众要更有耐心，给我们更多钱，更少来打扰我们，更别质疑我们的方法。”&lt;/p&gt;
&lt;p&gt;它用一个真实的宏观背景，掩盖一个同样真实的微观运作：对颠覆性创新充满结构性敌意的制度，正在日复一日摧毁我们摘高处的唯一希望。&lt;/p&gt;
&lt;p&gt;结论很明确：客观难度是真实的，但体系阻碍是致命的。我们感觉进展缓慢，不是因为站在贫瘠的土地上，而是因为我们正在用一个精心设计、功能紊乱的体系，去替代由好奇心驱动的、自由奔放的体系。这个替代品，效率极低，且扼杀天才。&lt;/p&gt;</description>
    </item>
    <item>
      <title>死区补偿和管压降补偿</title>
      <link>https://microcai.org/2026/06/30/Dead-time-compensation.html</link>
      <pubDate>Tue, 30 Jun 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/06/30/Dead-time-compensation.html</guid>
      <description>&lt;p&gt;死区补偿说的人很多，文章一大把。但是 igbt 的导通压降补偿似乎没什么人提。&lt;/p&gt;
&lt;p&gt;今天我就来一起说了。&lt;/p&gt;
&lt;h1 id=&#34;电压误差的由来&#34;&gt;电压误差的由来&lt;/h1&gt;
&lt;p&gt;变频器需要输出三相正弦波电流驱动电机平稳运行。要保证电流的正弦，首先需要保证电压的正弦。 &lt;strong&gt;除非用的是我前两天说的电流型控制器。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;但是，功率器件有各种办法让电机看到的电压不遵循正弦波。最大的2个，就是死区和 IGBT 的导通压降。&lt;/p&gt;
&lt;h2 id=&#34;死区时间&#34;&gt;死区时间&lt;/h2&gt;
&lt;p&gt;电压误差的第一大来源，就是死区时间。
为了防止上下2个管子同时打开，中间必须插入一个死区时间。类似十字路口的红绿灯，必须要插入一段4个路口都是红灯的时间来清空路口的车辆。&lt;/p&gt;
&lt;p&gt;插入多少死区时间，完全取决于器件的关断速度。确保一个管子已经彻底关闭后，才打开另一个管子。在使用 IGBT 的时候，绝大多数场景下，死区时间都是高达 1us ~ 2us。&lt;/p&gt;
&lt;p&gt;微秒？看起来很短啊！错错错，很长！在 20khz 的开关周期下，一个周期一共也就 50us。 这死区时间一下子就占了 4% 的占空比！&lt;/p&gt;
&lt;p&gt;也就是说，软件给出的占空比指令，会被无端端的少掉 4个百分点。这不是损失 4%，是损失4个点。比如软件给出 10% 的占空比，结果实际硬件发的占空比只有 6% ！ 这是产生了高达 40% 的误差了。&lt;/p&gt;
&lt;p&gt;所以，这死区时间是必须得补，不补不行！否则占空比丢失非常严重，产生极大的误差。&lt;/p&gt;
&lt;hr&gt;
&lt;h3 id=&#34;1-死区时间内的物理过程以正电流为例&#34;&gt;1. 死区时间内的物理过程（以正电流为例）&lt;/h3&gt;
&lt;p&gt;假设 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;mo&gt;&amp;gt;&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt; I &amp;gt; 0 &lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;（电流从母线流向负载），桥臂工作在互补PWM模式：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;理想情况&lt;/strong&gt;：上管导通 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;D&lt;/mi&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;msub&gt;&lt;mi&gt;T&lt;/mi&gt;&lt;mi&gt;s&lt;/mi&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;D \times T_s&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;，下管导通 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mo stretchy=&#34;false&#34;&gt;(&lt;/mo&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;mo&gt;−&lt;/mo&gt;&lt;mi&gt;D&lt;/mi&gt;&lt;mo stretchy=&#34;false&#34;&gt;)&lt;/mo&gt;&lt;mo&gt;×&lt;/mo&gt;&lt;msub&gt;&lt;mi&gt;T&lt;/mi&gt;&lt;mi&gt;s&lt;/mi&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;(1-D) \times T_s&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;实际开关过程&lt;/strong&gt;：
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;上管关断&lt;/strong&gt;：进入死区 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;msub&gt;&lt;mi&gt;T&lt;/mi&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;T_d&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;死区内&lt;/strong&gt;：上管、下管都处于关断状态。由于电感电流不能突变，负载电流必须通过&lt;strong&gt;下桥臂的反并联二极管&lt;/strong&gt;续流。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;续流路径&lt;/strong&gt;：电流从负载 → 下管二极管 → 直流母线负极（或中点）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;输出电压&lt;/strong&gt;：在这个死区时间内，桥臂中点电压被&lt;strong&gt;钳位在 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mo&gt;−&lt;/mo&gt;&lt;msub&gt;&lt;mi&gt;V&lt;/mi&gt;&lt;mrow&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;/mrow&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;-V_{dc}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/strong&gt;（或0V，取决于母线拓扑，对于两电平逆变器，被钳位到负极母线，即 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;mi&gt;V&lt;/mi&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt; 0V &lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt; 或 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mo&gt;−&lt;/mo&gt;&lt;msub&gt;&lt;mi&gt;V&lt;/mi&gt;&lt;mrow&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;/mrow&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;-V_{dc}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;；对于正负母线，被钳位到 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mfrac&gt;&lt;mrow&gt;&lt;mo&gt;−&lt;/mo&gt;&lt;msub&gt;&lt;mi&gt;V&lt;/mi&gt;&lt;mrow&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;/mrow&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mfrac&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;\frac{-V_{dc}}{2}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt; 或 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mo&gt;−&lt;/mo&gt;&lt;msub&gt;&lt;mi&gt;V&lt;/mi&gt;&lt;mrow&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;/mrow&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;-V_{dc}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结果&lt;/strong&gt;：理想情况下，这段时间本应输出一个高电平（如果这是有效导通时间的一部分）或低电平，但由于死区强制插入，实际输出在一个短暂区间内被拉到了&lt;strong&gt;与理想指令相反的极性&lt;/strong&gt;。&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;h3 id=&#34;2-死区造成的电压误差表达式&#34;&gt;2. 死区造成的电压误差表达式&lt;/h3&gt;
&lt;p&gt;由于死区导致输出在 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;msub&gt;&lt;mi&gt;T&lt;/mi&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt; T_d &lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt; 时间内偏离了理想值，因此造成的 &lt;strong&gt;“有效占空比损失”&lt;/strong&gt; 如下：&lt;/p&gt;</description>
    </item>
    <item>
      <title>电流模式 FOC</title>
      <link>https://microcai.org/2026/06/28/current-mode-foc.html</link>
      <pubDate>Sun, 28 Jun 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/06/28/current-mode-foc.html</guid>
      <description>&lt;p&gt;记得很久以前，我曾经说过，&lt;strong&gt;现有的FOC电机驱动都是电压模式控制&lt;/strong&gt;而遭到嘲讽。&lt;/p&gt;
&lt;p&gt;我其实明白这些半桶水为何会嘲讽。因为他们只学了半桶水，知道了 foc 就是控制电流进而控制磁场矢量。&lt;/p&gt;
&lt;p&gt;foc 满脑子都是电流，怎么会是电压模式控制呢？&lt;/p&gt;
&lt;p&gt;foc 确实核心是电流，但是在计算出电流之后，还是要使用 电流PID控制器，生成最终的每相占空比，进而控制开关管输出电压。&lt;/p&gt;
&lt;p&gt;也就是说，从硬件拓扑上看， foc 是一个电压型pwm控制器。通过控制电压来间接控制电流。&lt;/p&gt;
&lt;h1 id=&#34;电流型控制&#34;&gt;电流型控制&lt;/h1&gt;
&lt;p&gt;电流型控制器，则不控制电压，而是直接控制“电感电流”。不管是平均电流还是峰值电流，都是直接控制的电流。电流到达给定目标后， MOS管关闭。&lt;/p&gt;
&lt;p&gt;电流型控制普遍被应用在 DC/DC 和 AC/DC 控制器里。电压是输出电流扣去负载后，在输出电容上的积分。具有控制简单，容易补偿，可以并联输出，逐周期限流等多重好处。&lt;/p&gt;
&lt;p&gt;但是，好像，从未有人尝试过，在 电机驱动里，使用电流型PWM控制。&lt;/p&gt;
&lt;h1 id=&#34;硬件电流模式foc控制的优势&#34;&gt;硬件电流模式foc控制的优势&lt;/h1&gt;
&lt;p&gt;优势就是在不提高开关频率的情况下，拥有十倍于电压型逆变器的电流环带宽。
然后就是天然的免疫 功率管引入的非线性失真，如死区时间，导通压降，续流压降，等等。&lt;/p&gt;
&lt;h1 id=&#34;电机驱动上使用电流型的难点&#34;&gt;电机驱动上使用电流型的难点&lt;/h1&gt;
&lt;p&gt;电机有三相线，意味着需要3个电流pwm控制。&lt;/p&gt;
&lt;p&gt;但是，众所周知，三相电其实只有2个自由度。因为 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;Ia + Ib + Ic = 0&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;。这导致，3个电流环在硬件上会相互耦合干扰，导致环路崩溃。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;致命的冲突：如果你硬要给 A, B, C 三相各自接一个独立的硬件比较器（比如滞环控制器）。当 A 相硬件认为电流太小、下令打开上桥让 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;msub&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/msub&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;I_{a}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt; 上升时，根据电荷守恒，这一瞬间势必会导致 B 相或 C 相的电流同步发生下降。&lt;/li&gt;
&lt;li&gt;连锁反应： 此时，B 相或 C 相的硬件比较器一看自己的电流无故跌落，会立刻做出激烈的反向抗议动作，强行改变自己开关管的状态去顶回电流。&lt;/li&gt;
&lt;li&gt;崩溃结果： 三个完全独立的硬件电路为了抢夺这仅有的 2 个自由度，会陷入互不相让、无序抢占的“死锁”和高频恶性振荡状态。在功率电路上，这表现为无规律的剧烈毛刺噪声，管子成对烧毁或驱动芯片直接保护退饱和，即环路彻底崩溃。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果只引入 2个 pwm 控制，则第三个相线没办法接！即不可能直接接母线负极，也不能直接接母线正极。&lt;/p&gt;
&lt;p&gt;因此，3个相线，还就是必须使用3个半桥。也就意味着，得使用3路PWM ———— 所以还是需要3个pwm控制器。&lt;/p&gt;
&lt;p&gt;怎么办呢？&lt;/p&gt;
&lt;h1 id=&#34;不连续pwm调制救场&#34;&gt;不连续PWM调制救场。&lt;/h1&gt;
&lt;p&gt;&lt;img alt=&#34;alt text&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/dpwm.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;注意看 dpwm 调制波，任意时刻，只有2个桥臂工作在 pwm 模式。剩下一个桥臂，要么钳位在 0v 要么钳位在 Vdc 。&lt;/p&gt;</description>
    </item>
    <item>
      <title>异步电机控制何以复杂</title>
      <link>https://microcai.org/2026/05/25/IM-motor-is-hard.html</link>
      <pubDate>Mon, 25 May 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/05/25/IM-motor-is-hard.html</guid>
      <description>&lt;p&gt;一言以蔽之：因为有两个控制维度。&lt;/p&gt;
&lt;h1 id=&#34;控制维度&#34;&gt;控制维度&lt;/h1&gt;
&lt;p&gt;在自动控制系统里，系统通过传感器观察被控对象，然后通过执行器施加控制。
传感器的输入，被称为 被控量，而传递给执行器的命令，叫控制量。&lt;/p&gt;
&lt;p&gt;当一个被控量可以用多个控制量影响的时候，这个控制量的数量，就是控制维度。&lt;/p&gt;
&lt;p&gt;绝大多数时候，我们都喜欢一维控制。
为何呢？&lt;/p&gt;
&lt;h2 id=&#34;一维控制&#34;&gt;一维控制&lt;/h2&gt;
&lt;p&gt;还是拿电机举例。先举例直流有刷电机。&lt;/p&gt;
&lt;p&gt;被控量是电机转速，控制量是 电压，或者占空比。&lt;/p&gt;
&lt;p&gt;控制器要影响电机的转速，唯一能控制的量，就是自己输出给电机的电压。&lt;/p&gt;
&lt;p&gt;有的人说是电流？但是电流也是电压的结果。控制电流大小归根结底也是通过控制输出电压实现的。&lt;/p&gt;
&lt;p&gt;如果把有刷电机，换成无刷电机。&lt;/p&gt;
&lt;p&gt;看似执行机构变了， MOS 管数量从4个变成了 6个。&lt;/p&gt;
&lt;p&gt;但是，实际上控制器最终能控制的量，也只有唯一的一个：电压。&lt;/p&gt;
&lt;p&gt;因为对于无刷电机来说，控制器输出的是三相平衡交流电。&lt;/p&gt;
&lt;p&gt;三相平衡的交流电，实际上有2个自由度：电压和频率。
因为是三相平衡的，因此3条线的电压，实际上只有一个自由度，而不是3个。&lt;/p&gt;
&lt;p&gt;看似控制器可以控制电压和频率2个量，实际上控制器只能控制电压。&lt;/p&gt;
&lt;p&gt;因为对于永磁同步电机来说，输入的交流电的频率和相位，必须和转子同步。
意味着，频率或者相位，并不是一个可选的自由度，必须跟随转子同步。&lt;/p&gt;
&lt;p&gt;控制器唯一能控制的量，就剩下了一个：电压。&lt;/p&gt;
&lt;p&gt;这也是为何永磁同步电机，或者说无刷电机，大受欢迎。因为控制起来和直流有刷电机是一模一样的，都是唯一一个电压这个控制量。&lt;/p&gt;
&lt;h2 id=&#34;二维控制&#34;&gt;二维控制&lt;/h2&gt;
&lt;p&gt;但是，如果电机换成了异步电机，情况就发生了翻天覆地的变化。&lt;/p&gt;
&lt;p&gt;因为，异步电机是“异步”的。控制器输出的三相电，频率，还真就有了自由度。他不必跟随转子同步。甚至绝对不能和转子同步。还必须有个差。&lt;/p&gt;
&lt;p&gt;更要命的是，增加电压和提高频率，二者都可以提高电机转速： 也就是说，如果电机转速（被控制量）和实际目标有偏差，控制器有2个自由度实施校正：它可以改变电压，也可以改变频率。&lt;/p&gt;
&lt;p&gt;2个控制自由度，看似 “灵活” 实则给控制算法摆出了一个天大的难题。&lt;/p&gt;
&lt;h2 id=&#34;异步电机的矢量控制&#34;&gt;异步电机的矢量控制&lt;/h2&gt;
&lt;p&gt;电机控制，控制的是磁场。异步电机的运行原理和同步电机并没有本质区别：定子磁场带着转子磁场运动。&lt;/p&gt;
&lt;p&gt;无非是，同步电机的转子磁场被转子物理锁定，转子磁场和转子本身没有相对运动。
而异步电机的转子磁场和转子本身有一个漂移运动。&lt;/p&gt;
&lt;p&gt;如果先无视这个漂移运动呢？那么就可以使用和无刷电机一模一样的算法来控制定子磁场了。&lt;/p&gt;
&lt;p&gt;于是这个2个控制自由度，就下降为一个了。&lt;/p&gt;
&lt;p&gt;真的吗？&lt;/p&gt;
&lt;p&gt;异步电机的矢量控制，本质上是把异步电机这一个整体，看成了 一个同步电机+液力变矩器。液力变矩器的输入和输出之间，有一个转速差，所传递的扭矩大小，正比于这个转速差。&lt;/p&gt;
&lt;p&gt;但是，困难的地方在于，这个同步电机无法安装传感器，传感器只能安装在液力变矩器的输出端。&lt;/p&gt;
&lt;p&gt;于是这个（虚拟的）同步电机的转子，其磁场的真正朝向，就只能靠“猜”了。&lt;/p&gt;
&lt;p&gt;而要猜，就必须依靠电机的电动力学方程。要求解，就必须带入电机参数。&lt;/p&gt;
&lt;p&gt;恰恰这个“电机参数”，是非常难以精确获得的。他随着工况会随时变化。&lt;/p&gt;
&lt;p&gt;哪怕我们忽略这部分的困难，还有另一个问题：&lt;/p&gt;
&lt;p&gt;这个液力变矩器对扭矩的传递，也有控制量！&lt;/p&gt;
&lt;p&gt;因此，实际上还是有2个控制自由度。完全没有下降。&lt;/p&gt;
&lt;p&gt;对于一个控制偏差，算法既可以调整（虚拟的）同步电机的转速来修正，也可以通过调节液力变矩器的传递效率（扭矩增益）进行修正。&lt;/p&gt;
&lt;p&gt;因此， 异步电机的矢量控制，实际上它的控制量也是两个，
不是  电压+频率， 而是 电压+液力变矩器的扭矩增益。&lt;/p&gt;
&lt;p&gt;自由度实际上完全没有下降。&lt;/p&gt;
&lt;p&gt;还带来了这个 （虚拟的）同步电机 转子位子本身的猜测困难问题。&lt;/p&gt;
&lt;p&gt;哪怕加了传感器，还是需要电机参数，还需要“猜”转子磁场位置。&lt;/p&gt;
&lt;p&gt;传感器加了一个寂寞。&lt;/p&gt;
&lt;p&gt;要知道，在永磁同步电机控制里，物理上的传感器可以让控制器完全抛弃电机参数。只有无传感器控制才依赖电机参数去猜转子的位置。&lt;/p&gt;
&lt;p&gt;因此，矢量控制放到异步电机上，其实就是死路一条。&lt;/p&gt;
&lt;h2 id=&#34;转差频率控制&#34;&gt;转差频率控制&lt;/h2&gt;
&lt;p&gt;在 转差频率控制 里，我们认为，异步电机的扭矩 = 转差频率*励磁电流。&lt;/p&gt;</description>
    </item>
    <item>
      <title>异步电机控制</title>
      <link>https://microcai.org/2026/05/10/closeloop-vfd.html</link>
      <pubDate>Sun, 10 May 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/05/10/closeloop-vfd.html</guid>
      <description>&lt;h1 id=&#34;超越开环&#34;&gt;超越开环&lt;/h1&gt;
&lt;p&gt;要不怎么说， AI 极大的促进了知识的传播。&lt;/p&gt;
&lt;p&gt;我很多年前，就做了一个变频器。&lt;/p&gt;
&lt;p&gt;但是，一直都是使用 V/F 开环控制。&lt;/p&gt;
&lt;p&gt;使用开环控制，简单，好用，便宜。&lt;/p&gt;
&lt;p&gt;但是，如何进行闭环控制呢？&lt;/p&gt;
&lt;h1 id=&#34;滑差频率控制&#34;&gt;滑差频率控制&lt;/h1&gt;
&lt;p&gt;我第一时间就想到了控制滑差率。&lt;/p&gt;
&lt;p&gt;一开始，我的想法是这样的：&lt;/p&gt;
&lt;p&gt;假设控制目标是一个转速。转速 S 是控制目标。&lt;/p&gt;
&lt;p&gt;直接输出 S+转差 是不行的。
所以，需要几个 PID 控制环。&lt;/p&gt;
&lt;p&gt;我最初的设想是这样的，如果是一台直流电机，做闭环转速控制是怎么做的？&lt;/p&gt;
&lt;p&gt;答案是  转速环-》扭矩环（电流环）-》PWM 占空比。&lt;/p&gt;
&lt;p&gt;或者，可以一步到位，转速环-》PWM 占空比。&lt;/p&gt;
&lt;p&gt;转速高了，就降低 pwm 占空比，低了，就提高占空比。占空比本质上是控制电压。&lt;/p&gt;
&lt;p&gt;于是，我在异步电机这里，这么设计：&lt;/p&gt;
&lt;p&gt;转速环-》电压。&lt;/p&gt;
&lt;p&gt;然后根据转差率，直接确定输出频率。频率不用一个闭环进行控制，而是通过测量转速，直接乘上一个转差率，得到输出频率。&lt;/p&gt;
&lt;p&gt;这个转差率，由当前的负载情况，可以直接计算出一个最优转差率。所谓最优转差率，就是效率最高的转差率。低了，铁损增加，高了，铜损增加。&lt;/p&gt;
&lt;p&gt;然后，我遇到了一个很现实的问题：就是转速环一开始就会输出一个很高的电压！&lt;/p&gt;
&lt;p&gt;但是，我认为，可以加入一个恒流恒压控制。只要设定了最大电流，电压就自动被控制住了。&lt;/p&gt;
&lt;p&gt;然而，现实的情况是，这种限制最大电流的模式，其实并不适用。这意味着启动的时候电机会一直处于磁通饱和状态。而且这种饱和状态，还使用个屁的最佳转差率，根本就破坏了最佳转差率的存在前提嘛。&lt;/p&gt;
&lt;p&gt;经过和 AI 的反复沟通，推翻了各种方案，最终我确定了以下方案：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;转速环（输出扭矩参考）-》扭矩环（输出频率）&lt;/li&gt;
&lt;li&gt;电流环（维持励磁电流）-》输出电压&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;电流环是独立运行的一个控制环，他控制输出电压，以维持在当前频率下的励磁电流为一个定值。&lt;/p&gt;
&lt;p&gt;扭矩环接受转速环（或者位置环）的输出，根据转子转速直接确定输出频率。&lt;/p&gt;
&lt;p&gt;这个频率的确定方式是：输出频率 = 转子频率 + 扭矩参考*最大转差频率。&lt;/p&gt;
&lt;p&gt;扭矩参考是一个 [-1,1] 的数值。最大转差频率是和电机有关的一个参数，计算方式是：最大转差频率 = 转子的电阻 ÷ (2π × 转子的电感)&lt;/p&gt;
&lt;h2 id=&#34;滑差频率控制的底层物理原理&#34;&gt;滑差频率控制的底层物理原理&lt;/h2&gt;
&lt;p&gt;为啥是这个频率呢？因为异步电机的扭矩，说到底是定子磁场*转子磁场*攻角。&lt;/p&gt;
&lt;p&gt;而转子磁场，就是由 转差频率 供电的。
当转子的电阻和电抗相等的时候，转子电流出现最大值。继续提高转差频率，转子电抗会增加导致电流下降。因此，使转子的电阻和电抗相等的频率，就是最大转差频率。&lt;/p&gt;
&lt;p&gt;更进一步的来说，电机扭矩 = 定子磁场矢量 叉乘 转子磁场矢量。
这对任何电机都是成立的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>编译期构造只读容器</title>
      <link>https://microcai.org/2026/04/22/compile-time-container.html</link>
      <pubDate>Wed, 22 Apr 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/04/22/compile-time-container.html</guid>
      <description>&lt;p&gt;我在设计变频器的红外遥控处理的时候，定义了一个 map 容器。
这个容器很简单，就是一个 int 对 int 的映射。&lt;/p&gt;
&lt;p&gt;把 红外遥控器的按键ID, 映射到我内部定义的一个 枚举命令id 上。&lt;/p&gt;
&lt;p&gt;这样只要修改这个 map 容器，就可以适配多种红外遥控。&lt;/p&gt;
&lt;p&gt;但是，我发现，这个 map 容器哪怕定义为 const 变量也没用，他依旧是分配在内存里的。而且是分配在宝贵的堆内存里。&lt;/p&gt;
&lt;p&gt;不仅仅如此，这个 map 容器的构造还会在运行时分配大量的细碎内存块。&lt;/p&gt;
&lt;p&gt;除了占用运行时内存，他对单片机flash的占用并不消失。因为构造这个map所需的原始数据还是需要躺在 .rodata 段里。&lt;/p&gt;
&lt;p&gt;既然这个 map 容器是只读的，那么为啥我需要在运行时分配这么多的内存？
直接在编译期就构造好一个map，然后在运行时直接使用，岂不更好？&lt;/p&gt;
&lt;p&gt;我试着给 std::map 前面添加一个 constexpr 修饰符，结果编译失败。
看来 std.map 并不能简单的通过 constexpr 变成编译期构造。&lt;/p&gt;
&lt;p&gt;由于 单片机的内存有 8KB 之巨，很长一段时间里我都没有遇到内存不足问题。直到最近为了缩减代码体积，把一些本该无栈协程实现的代码替换成了有栈协程。编译后能缩减数个KB的体积。
结果遇到莫名其妙的硬件错误。调试了许久才发现原来是内存分配失败导致的。&lt;/p&gt;
&lt;p&gt;于是想在其他地方扣点内存出来，于是重新盯上了这个 map 容器。&lt;/p&gt;
&lt;p&gt;我最初的做法本来是想自己手搓一个。
但是，如此需求，难道真只有我有吗？&lt;/p&gt;
&lt;p&gt;如果并不是我独有的需求，应该已经有前人已经实现过了。不能动不动就重复发明轮子呀！&lt;/p&gt;
&lt;p&gt;于是我找啊找，找到了这个 &lt;a href=&#34;https://github.com/serge-sans-paille/frozen&#34;&gt;frozen&lt;/a&gt;  库。&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code class=&#34;language-cpp++&#34; data-lang=&#34;cpp++&#34;&gt;
#include &amp;lt;map&amp;gt;

static const std::map&amp;lt;ir_command, UserCommand&amp;gt; ir_command_map = {
	{0x0002000D, UserCommand::speed_0},
    ...
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这样的代码，被替换成了&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code class=&#34;language-cpp++&#34; data-lang=&#34;cpp++&#34;&gt;#include &amp;lt;frozen/map.hpp&amp;gt;

static constexpr frozen::map&amp;lt;ir_command, UserCommand, 41&amp;gt; ir_command_map = {
	{0x0002000D, UserCommand::speed_0},
    ...
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;然后重新编译，代码体积略微膨胀。但是运行时的堆内存占用一下减小千余字节。
代码膨胀，是因为原来编译器会把这 41 个 KV 对，一共 82 个数字存在 .rodata 段里, 然后在 启动的时候调用构造函数构造 map。如今编译器直接在 .rodata 段里构造出一个 map 容器的二叉树。在运行时直接在这个只读的，放在 FLASH 而不是 RAM 里的 二叉树进行查找。不需要构造了。因此减少了 RAM 的使用。但是存在 .rodata 段的二叉树，比原始的82个整数要多占一些空间。&lt;/p&gt;</description>
    </item>
    <item>
      <title>搞懂环路补偿</title>
      <link>https://microcai.org/2026/02/13/loop-compensation-explain.html</link>
      <pubDate>Fri, 13 Feb 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/02/13/loop-compensation-explain.html</guid>
      <description>&lt;p&gt;经常设计模拟电路的朋友会发现，运放的输出端通常需要串入一个补偿网络到反向输入端。&lt;/p&gt;
&lt;p&gt;如下图所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/op_loop_compensation.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;R1 C1 C2 构成了一个补偿网络。&lt;/p&gt;
&lt;p&gt;这是为何呢？&lt;/p&gt;
&lt;h1 id=&#34;闭环系统的稳定性&#34;&gt;闭环系统的稳定性&lt;/h1&gt;
&lt;p&gt;闭环系统，就是消灭跟踪误差。
消灭的方式，就是对误差进行放大，然后进行反向调节——“负反馈”。&lt;/p&gt;
&lt;p&gt;理想的运放，有无穷大的放大倍数，和 0 延迟。&lt;/p&gt;
&lt;p&gt;然而现实世界不是理想世界，显示中的运放是有延迟的，放大倍数也不是无穷大。&lt;/p&gt;
&lt;p&gt;放大倍数对运放的稳定性其实关系不大，主要是放大延迟：即输入信号发生改变的时候，输出信号能多快的反应过来并跟踪输入的变化。&lt;/p&gt;
&lt;p&gt;为什么这个反应速度很重要呢？&lt;/p&gt;
&lt;p&gt;因为反应慢了，会导致“运放振荡”。&lt;/p&gt;
&lt;p&gt;为什么反应慢了会振荡呢？&lt;/p&gt;
&lt;p&gt;如上图的运放，在稳态时，其2个输入端的电压是相同的。当输入信号发生变化的时候，比如，增加。
则运放需要提高输出电压，以抬高其反相输入端的电压，最终使得2个输入端的电压相同。&lt;/p&gt;
&lt;p&gt;如果运放抬高输出端的电压不够快，有延迟，此时同相输入的电压就已经跌落。那么经过延迟后，运放的反相输入端电压就会超过同相输入端。&lt;/p&gt;
&lt;p&gt;此时运放不得不降低输出电压，而他每次进行调节的时候，都总是反应慢一拍，导致每次都会“过调”。过调后又要反向调节，但是因为延迟的缘故，始终无法稳定下来。
于是运放就进入了振荡。&lt;/p&gt;
&lt;p&gt;也就是，输入的一个扰动，会导致运放的输出产生非常多的来回振荡。而这个来回振荡又反过来引起跟多的来回振荡。&lt;/p&gt;
&lt;p&gt;那么如何从数学上精确的描述运放的这种“来回振荡”的行为呢？&lt;/p&gt;
&lt;p&gt;专门用来描述闭环系统的稳定性的数学工具，就是 频率响曲线，包括 增益曲线和相位延迟两个子图。&lt;/p&gt;
&lt;p&gt;也就是，运放对每一个频率的输入，他对这个频率会产生多大幅度的“增益”（放大倍数），以及对这个频率他会有多少延迟（转化为相位延迟表示）。&lt;/p&gt;
&lt;p&gt;如下面这个：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/loop_gain_phase_curve.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;一条增益曲线，一条相位延迟曲线，就完整的描述了一个系统的行为逻辑了。
那么，对于一个闭环系统，什么样的曲线，算是“稳定”的呢？（稳定，即发生扰动后不会发生来回振荡）&lt;/p&gt;
&lt;p&gt;答案是，在整个增益 &amp;gt;0db 的部分，其相位延迟全部都 &amp;lt; 180度。在工程上为了留有一定的余量，通常会要求延迟 &amp;lt;150度，乃至 120度。增益 = 0db 的频率，姑且起个名字叫穿越频率。&lt;/p&gt;
&lt;p&gt;增益 &amp;lt;1 的部分，哪怕延迟 &amp;gt; 180，导致的振荡也是“阻尼振荡”。因此系统还是稳定的，只不过不是很优秀。也就是说，我们希望在延迟 =180度的那个频率，他离穿越频率越远越好，系统在扰动下的恢复时间就会越短。&lt;/p&gt;
&lt;p&gt;于是就有了相位裕度。相位裕度指的是在穿越频率上，距离180度的不稳定极限，还剩下多少。相位裕度越大，说明系统就越稳定。&lt;/p&gt;
&lt;p&gt;为什么延迟要 &amp;lt; 180度 呢？ 因为运放是一个“负反馈”系统。如果运放的输出和输入之间有了 180度的延迟，则运放实质上会变成一个正反馈。正反馈就使得运放产生自激振荡。&lt;/p&gt;
&lt;h1 id=&#34;如何修正反馈的稳定性&#34;&gt;如何修正反馈的稳定性&lt;/h1&gt;
&lt;p&gt;修正它，有一个很简单的办法：将超过穿越频率的信号给过滤掉。
只要输入给运放的信号，其频率成分总是小于穿越频率，运放就没有机会不稳定了。&lt;/p&gt;
&lt;p&gt;那么为什么一般是在输出端和反向输入端之间，连接高通滤波器而不是在输入端使用低通滤波器呢？
因为补偿网络还有一个重要功能，是调节穿越频率本身！&lt;/p&gt;
&lt;p&gt;这个功能特点，对于“电源类应用”是非常必要的。&lt;/p&gt;
&lt;p&gt;补偿网络，通过前馈调节，提前补偿运放的反馈链，从而实质上从输出去除掉部分信号。所以补偿网络，从形式上看，通常是一个高通滤波器。不响应低频信号，从而不调节低频增益。对于高频信号，让运放的输入输出直通从而压制高频增益。
因此，补偿网络的截止频率，就变成了此时整个环路的穿越频率。而在输入端使用低通滤波器则起不到这个作用。同时补偿网络对低频的相位延迟影响微乎其微，而输入低通滤波器则会引入更多的相位延迟，并不利于环路的稳定。&lt;/p&gt;
&lt;h1 id=&#34;使用何种类型补偿网络&#34;&gt;使用何种类型补偿网络&lt;/h1&gt;
&lt;p&gt;使用何种类型的补偿网络，关键在于系统未进行补偿的情况下，其环路的频率响应情况。理想的补偿网络，是系统使用了补偿网络后，其频响曲线变成一条直线。
然而这是不可能的。因此，退而求其次，选择补偿网络，就是压制高频增益，降低穿越频率，提高相位裕度。对于一些出现二次穿越的情况，还需要使用带通滤波器设计的环路补偿器。&lt;/p&gt;
&lt;p&gt;因此，系统原有的频响特性，决定了补偿的类型。&lt;/p&gt;
&lt;p&gt;为什么说电流模式 PWM 控制好？好就好在他的补偿器容易设计。电流模式pwm控制器，其补偿网络简单到，只需要将穿越频率压低到开关频率的1/10就能使环路稳定。而电压型pwm控制，补偿网络还要引入微分积分器，对占空比的变化将要引起的电压变化进行预测—— 也就是不能简单的压制穿越频率。或者说，电压信pwm控制器，不进行补偿的情况下，其极点频率太低，使得只是降低穿越频率变得不可能。需要降低穿越频率的同时提高极点频率——简单的来说，就是补偿器自身的频响应要实现相位提前。&lt;/p&gt;</description>
    </item>
    <item>
      <title>极坐标变换中的负电流</title>
      <link>https://microcai.org/2026/01/16/negative-current-in-polar-foc.html</link>
      <pubDate>Fri, 16 Jan 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/01/16/negative-current-in-polar-foc.html</guid>
      <description>&lt;p&gt;三相电流进行采样后，采集到的电流是有正有负的。因为采集的是相电流，而且相电流是交流电，因此必然会出现有正有负的情况。&lt;/p&gt;
&lt;p&gt;相电流经过矢量合成，必然可以表现为在极坐标上的一条向量。&lt;/p&gt;
&lt;p&gt;此时，这个向量，只有幅值和角度。&lt;/p&gt;
&lt;p&gt;这个幅值，是正数。&lt;/p&gt;
&lt;p&gt;我们都知道，电机在运行过程中，会产生反电动势，反电动势高于输入电压的情况下，电机会表现为发电机，对外输出能量。在机械上就是表现为，产生拖拽，也就是俗称电机输出了负扭矩。&lt;/p&gt;
&lt;p&gt;在极坐标上看，就是电流的矢量和转子产生了负夹角。&lt;/p&gt;
&lt;p&gt;这个负夹角，对控制算法来说，实际上是不利的。&lt;/p&gt;
&lt;p&gt;为何这么说呢？&lt;/p&gt;
&lt;p&gt;这意味着控制算法不仅仅要考虑电流的大小，还要考虑电流的大小（扭矩大小）还得考虑和转子的夹角是正（定子磁场带着转子走）还是负（转子被定子磁场拖拽）。&lt;/p&gt;
&lt;p&gt;因此，在三相电流采样后转电流矢量这个坐标转化算法里，必须同时输入转子角度，然后把负夹角处理为负电流，正夹角。&lt;/p&gt;
&lt;p&gt;这样，电流采样模块输出的就是负电流，而负电流，就可以被 电流调节PID模块 正确的处理，产生更高的输出电压来抵消反电动势，以便扭转负电流为正电流。&lt;/p&gt;
&lt;p&gt;同时， SVPWM 调制模块，也必须接受 “负电压” 这样的输入，以简化 电流调节PID模块 的控制算法。&lt;/p&gt;
&lt;p&gt;所谓负电压，其实就是电压矢量转180度。&lt;/p&gt;
&lt;p&gt;经过这样负电流负电压的处理后，正反转控制，就简单的变成了正电流和负电流的控制，同时避免了 “夹角PID模块” 对反转的考虑。 注意，负电流！=发电。只有 电流和电压的乘积为负，才是发电。&lt;/p&gt;
&lt;p&gt;反转的时候，电流采集到的是负电流，电流环输出的是负电压。功率一样是正的。夹角一样是正 90度。也就是说，负责调节电流和转子夹角的PID算法，不需要根据正反转决定是正90度还是负90度夹角，统统处理成90度。&lt;/p&gt;</description>
    </item>
    <item>
      <title>Clarke-park 变换毫无意义</title>
      <link>https://microcai.org/2026/01/01/clarke-park-is-useless.html</link>
      <pubDate>Thu, 01 Jan 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/01/01/clarke-park-is-useless.html</guid>
      <description>&lt;p&gt;电机领域有个很神奇的现象：人云亦云，不会思考。&lt;/p&gt;
&lt;p&gt;比如，早期有个教授写教材的时候说反电动势为梯形波的叫无刷，正弦波的叫永磁同步。
然后大家就跟着他这么说了，完全不会思考。&lt;/p&gt;
&lt;p&gt;而国内做电机的，基本上教程来自德州仪器的电机库。几十年时间过去了，还没有跳出德州仪器当年给国内的人画的地牢。完全不会思考。
离了 Clarke-park 变换，就不会做 foc 了。
更有人写 foc 教程的时候，大言不惭的说，FOC离不开Clarke-park 变换，还说没有这个变换就没有 foc。&lt;/p&gt;
&lt;p&gt;笑掉大牙，可是从业者都是这样的。不会思考，人云亦云。
长江大学的唐老师说的好，国内搞硬件的人，水平很差，喜欢对国外顶礼膜拜， 有问题都是自己的问题，但是如果国产的东西他自己水平次用出问题了，他又要怪国产芯片不行了，不找自己的问题了。
这种心态放到电机研究上，那就是永远不能跳出当年德州仪器规划出来的电机控制框架。
特别是，当德州仪器和 Matlab 合作搞出 simulink 电机控制开发套餐，国人就更不敢挑战了。
因为硬件领域是有一条鄙视链的，算法研究 》底层代码编写》搞应用落地的。
而 simulink 正好占据了电机算法研究领域的绝对统治地位。
搞研究的都用 simulink，他还处在鄙视链最上层，那么最下层的人就绝对不敢挑战权威，跳出 simulink 里的那套框架了。
特别是，中国搞电机研究的人，主要集中在高校里的 simulink算法党，和各大血汗工厂里的牛马应用党，最缺的是中间写底层代码的。因为这些活，被德州仪器等芯片工厂的“FAE”包了。
二十多年前，阿莫电子论坛上，有一个牛人在8051上手搓无刷电机驱动，被一些牛马党膜拜的同时，被另一批人嘲讽，有“原厂电机库” 好用吗？
他们的论据是，原厂电机库有很多不公开的高级算法，肯定是汇编写的，调用芯片底层资源的，你 C 写的肯定不行。
那么这个和 clarke -park 变换有什么关系呢？
因为德州仪器最早公开电机控制算法，“大公无私”的向下游公司提供电机控制库。还手把手的教他们怎么用。（大公无私打个引号，因为芯片是卖钱的。但是也算大公无私，因为他毕竟教了，而不是像日本公司那样只收钱，不教你）。
还做一系列的开发板，和 simulink 无缝集成。
无缝集成的意思是，在 simulink里动动鼠标，改改参数，就能让 simulink 自动生成一套基于 C2000 架构的电机控制代码。然后 simulink 自动调用德州仪器的编译器，下载到他的开发板上运行，一气呵成，只需要点  simulink 里的 “RUN”。。。。一行代码都不用写。
而这套体系，就是基于  Clarke -park 变换构建的。
可以说，这套 simulink 电机开发套件，就是国内一切电机开发的源头。
国内所有的论文，都是基于这套架构上做的开发。研究各种控制理论，也必须得先在这套架构上跑过才能发论文。&lt;/p&gt;
&lt;p&gt;这个就是 唯“clarke-park变换”是尊的源头。&lt;/p&gt;
&lt;p&gt;那么这个变换好不好呢？当然好，不好就不会被德州仪器选中。
但是，唯“clarke-park变换”是尊，正说明了国内的人不思进取，人云亦云。&lt;/p&gt;</description>
    </item>
    <item>
      <title>运算放大器运算了什么</title>
      <link>https://microcai.org/2025/12/29/opap-how-do-it-do.html</link>
      <pubDate>Mon, 29 Dec 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/12/29/opap-how-do-it-do.html</guid>
      <description>&lt;h1 id=&#34;什么是运放&#34;&gt;什么是运放&lt;/h1&gt;
&lt;p&gt;模拟电路的基础元件，有 二极管，三极管，电容，电阻，电感，还有&amp;hellip;&amp;hellip;.运放。&lt;/p&gt;
&lt;p&gt;运放，虽然这个基础结构实际上内部是由多个三极管构成的，但是，他依然是基础元件。&lt;/p&gt;
&lt;p&gt;而且这个基础元件，就好像电容电感一样，有一个“理论最优”的模型，但是实际上做不出来。&lt;/p&gt;
&lt;p&gt;这个理论模型，就是放大倍数无穷大。&lt;/p&gt;
&lt;p&gt;如果，只是放大倍数无穷大，运放是无法成为基础元件的。&lt;/p&gt;
&lt;p&gt;运放能成为基础元件，最关键的原因，是运放是一个图灵部件。&lt;/p&gt;
&lt;p&gt;运放在电路中最关键的作用，是执行“死循环”，使得模拟电路图灵完备。&lt;/p&gt;
&lt;h1 id=&#34;死循环&#34;&gt;死循环&lt;/h1&gt;
&lt;p&gt;模拟电路也是计算机。模拟计算也是计算。&lt;/p&gt;
&lt;p&gt;运放在模拟电路里最重要的功能，就是实现死循环，完成“闭环控制”。&lt;/p&gt;
&lt;p&gt;例如在一个开关电源里，运放在其中扮演的，就是精细调控占空比的角色。&lt;/p&gt;
&lt;p&gt;通过分压电阻采集目标电压（反馈输入），然后和基准电压（控制目标）进行比较，产生新的占空比电压（控制输出），最后由三角波比较器输出为占空比调制信号。&lt;/p&gt;
&lt;p&gt;这样一个 反馈输入-》比较控制目标-》输出控制信号 要变成一个死循环，快速的不断循环。
这个循环，就是由运放执行的。&lt;/p&gt;
&lt;p&gt;而且运放执行这个控制循环的速度，是数字电路望尘莫及的。运放执行这个控制循环的速度，就是运放的带宽。&lt;/p&gt;
&lt;p&gt;控制速度，不能高于开关速度。而运放的带宽远高于电力电子器件的开关速度。因此绝大多数情况下，我们要降低控制带宽。&lt;/p&gt;
&lt;p&gt;降低带宽的办法，不是让运放慢一点，而是修改反馈给运放的信号，让反馈信号慢下来。&lt;/p&gt;
&lt;p&gt;但是，运放的带宽实际上并没有下降。如果输入的信号有“延迟”。运放动作太快了，就会振荡。&lt;/p&gt;
&lt;p&gt;比如反馈电压低了，运放增大占空比，但是占空比增大后，反馈的电压不能立即反应，需要滞后一段时间。
此时运放就会因为反馈的电压一直很低，而不断增大 占空比。直到最初增大占空比的效果呈现，然后反馈回来的电压就会一下冲过头。此时运放就会反过来立即减小占空比。然后延迟达成效果后，再来个电压过低。&lt;/p&gt;
&lt;p&gt;然后运放又增大占空比。&lt;/p&gt;
&lt;p&gt;这样来回拉锯，始终不能稳定。这个就是反馈信号有延迟导致的运放振荡。&lt;/p&gt;
&lt;h1 id=&#34;运放的偿&#34;&gt;运放的偿&lt;/h1&gt;
&lt;p&gt;这个时候，就要进行一次前馈补偿。
所谓的前馈补偿，就是提前把运放 “增大占空比” 的效果给反馈给运放。免得运放认为反馈回来的信号一直不够而继续增大占空比，然后过冲。。。。&lt;/p&gt;
&lt;p&gt;在真实的占空比增大带来的反馈电压抬高之前，就提前把“反馈电压”给抬高。使得运放“以为”反馈电压已经正常了，就停止调节。&lt;/p&gt;
&lt;p&gt;这个就是运放必须要做前馈调节，而数字控制不需要的原因。因为数字控制可以直接修改算法实现。
但是运放的反馈调节算法是死的，是通过在 “反馈” 这个地方进行劫持来达成所谓的修改控制算法的目的。&lt;/p&gt;
&lt;p&gt;运放的补偿，实际上就是个预测器。&lt;/p&gt;
&lt;p&gt;提前把运放的输出结果进行预测，然后将预测值叠加在真实的反馈值之上，再送给运放。
这样运放就“认为”条件已经满足，从而停止调节。实现了运放的稳定运行，避免反复调节导致的震荡。&lt;/p&gt;
&lt;p&gt;运放的补偿通常由电容和电阻串联构成。&lt;/p&gt;
&lt;p&gt;电容的大小，决定了预测多久，电阻的大小，决定预测的结果叠多少回真实值。&lt;/p&gt;</description>
    </item>
    <item>
      <title>无传感器感应电机驱动</title>
      <link>https://microcai.org/2025/12/13/sensorless-induction-motor.html</link>
      <pubDate>Sat, 13 Dec 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/12/13/sensorless-induction-motor.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;我很喜欢异步电机。当然特指三相异步电机。如果是单相的，那是一点喜欢不起来。&lt;/p&gt;
&lt;p&gt;三相异步电机，如果需要精确的控制，总是需要转速传感器。有了转速传感器，就可以配合滑差率进行闭环控制。&lt;/p&gt;
&lt;p&gt;但是，传感器并不总是有的。很多时候，传感器安装不便，有的情况下，也是为了懒惰：没传感器的情况下只需要接3根线。&lt;/p&gt;
&lt;p&gt;没有传感器，如何获得转速呢？&lt;/p&gt;
&lt;p&gt;在无刷电机里，转子有磁场。有转速就可以发电。于是可以用反电动势大法获得转子的位置——连实时位置都有了，转速更有了。&lt;/p&gt;
&lt;p&gt;但是，在异步电机里，如何在无传感器的情况下获取转子速度呢？&lt;/p&gt;
&lt;h1 id=&#34;电流幅值和瞬时值&#34;&gt;电流幅值和瞬时值&lt;/h1&gt;
&lt;p&gt;异步电机说到底还是交流电驱动的。交流电过去后，就可以测量出电流的幅值和相对电压的相位差了。&lt;/p&gt;
&lt;p&gt;电流相对电压的相位差，也就是无功功率的由来。&lt;/p&gt;
&lt;p&gt;我们通过测量手段测量出来的，实际上是三条相线的相电流。Ia Ib Ic。在古代电机控制算法里，需要经过一个变换将他变成 Iq 和 Id。但是，这一个步骤，对无刷电机来说，首先需要知道电机的转子电角度，对异步电机来说，首先需要知道转差率。&lt;/p&gt;
&lt;p&gt;不如换一种变换方式，首先将他转换为通常意义上的 “电流”，也就是不带矢量的电流。这个电流，就是电功率 P=IU 里的那个电流。三相电虽然电流和电压的大小时刻在变化，但是它的功率是保持恒定的。因此他实际上有一个固定 I 和一个固定的 U. 这个固定的 I 和固定的 U 就是三相交流电的有效电压和有效电流。 这个等效电压，可以通过 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;占空比&lt;/mtext&gt;&lt;mo&gt;∗&lt;/mo&gt;&lt;mtext&gt;母线电压&lt;/mtext&gt;&lt;mi mathvariant=&#34;normal&#34;&gt;/&lt;/mi&gt;&lt;msqrt&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msqrt&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;占空比*母线电压 / \sqrt{2}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;计算出来，而这个等效电流，如何快速的通过 Ia Ib Ic 计算出来呢？&lt;/p&gt;
&lt;p&gt;答案是，通过矢量合成。由于 Ia Ib Ic 是在空间上错开120度的矢量，经过合成，就知道了这个合成矢量的模。&lt;/p&gt;
&lt;p&gt;于是
&lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;msqrt&gt;&lt;mrow&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mi mathvariant=&#34;normal&#34;&gt;/&lt;/mi&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;∗&lt;/mo&gt;&lt;mo stretchy=&#34;false&#34;&gt;(&lt;/mo&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;msup&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;msup&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;I&lt;/mi&gt;&lt;msup&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;mo stretchy=&#34;false&#34;&gt;)&lt;/mo&gt;&lt;/mrow&gt;&lt;/msqrt&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;
I = \sqrt{2/3*(Ia^2 + Ib^2 + Ic^2 ) }
&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;这样计算获得的就是每相电的有效值。&lt;/p&gt;
&lt;p&gt;因此，在任意时刻，程序手头能立刻获得的实时数据有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1：输出电压幅值
2：输出频率
3：相电流有效值
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而此时要求得的是，滑差率，从而确定下一个周期的 输出频率。&lt;/p&gt;
&lt;p&gt;凭借这4个参数，能否求得滑差率呢？&lt;/p&gt;
&lt;p&gt;答案是，不能。&lt;/p&gt;
&lt;p&gt;因此，还需要添加额外的参数：也就是所谓的电机参数。&lt;/p&gt;
&lt;p&gt;这个额外的电机参数是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1：定子电阻
2：鼠笼绕组的等效电阻
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;有了这额外的2个参数，能否计算出滑差率呢？&lt;/p&gt;
&lt;p&gt;那么，我们来看，滑差率如何影响电流的幅值和相位。&lt;/p&gt;
&lt;p&gt;首先我们知道，定子输入的功率P一部分被定子的电阻消耗，而另一部分不会凭空消失，肯定是转移给了转子。&lt;/p&gt;
&lt;p&gt;因此，转子消耗的功率&lt;/p&gt;</description>
    </item>
    <item>
      <title>反激电源里 tl431&#43;pc817 组合下对比 Boost 是怎么实现稳压的</title>
      <link>https://microcai.org/2025/10/21/tl431-pc817.html</link>
      <pubDate>Tue, 21 Oct 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/10/21/tl431-pc817.html</guid>
      <description>&lt;p&gt;以前说过，反激就是隔离的 Boost。&lt;/p&gt;
&lt;p&gt;在 Boost 升压电路里，稳压靠的是 一个分压网络和芯片的 FB 引脚。
芯片自动调节占空比，使得 FB 引脚电压被稳定在内部参考电压。从而间接的将输出电压稳定。&lt;/p&gt;
&lt;p&gt;在反激电源里，同样也是靠芯片的 FB 引脚反馈。但是此时反馈信号来自 PC817 而不是分压电阻。
pc817 则受 tl431 驱动。&lt;/p&gt;
&lt;p&gt;实际上，这里和 boost 拓扑里是一样的。就是比较分压和参考电压。
在 Boost 拓扑里，参考电压是芯片内置的。而在 pc817+tl431 的组合里，这个参考电压，就是 tl431。&lt;/p&gt;
&lt;p&gt;tl431 通过控制 pc817 的导通，来间接调控反激控制器的占空比。tl431 流过电流越大，则 pc817 的内部发光二极管
流过的电流也越大。于是 pc817 的输出三极管的电流也越大。&lt;/p&gt;
&lt;p&gt;pc817 通常用于将反激芯片的 FB 引脚（芯片会内部上拉）拉低。也就是 pc817 的二极管流过电流越大，反激芯片的 FB 引脚电压就被拉的越低。&lt;/p&gt;
&lt;p&gt;反激芯片的 FB 引脚电压越低，反激芯片的 pwm 占空比就越低。&lt;/p&gt;
&lt;p&gt;以DK1203为例子，他的 FB 引脚电压在 2.3V-2.5V 之间可以线性的调控占空比 0%-100%。高于 2.6V 芯片进入短路保护，低于 2.3V 芯片进入过压保护。
因此， tl431 可以通过 pc817 直接调控反激芯片的占空比。从而稳定输出电压。&lt;/p&gt;
&lt;p&gt;如果将 boost 芯片用于反激，则 pc817 的输出要改成对 FB 进行上拉。&lt;/p&gt;</description>
    </item>
    <item>
      <title>电机类型优劣对比</title>
      <link>https://microcai.org/2025/09/30/motor-type-compare.html</link>
      <pubDate>Tue, 30 Sep 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/09/30/motor-type-compare.html</guid>
      <description>&lt;p&gt;不同电机的优劣对比整理归纳。&lt;/p&gt;
&lt;p&gt;先说单相异步电机：&lt;/p&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;只需要单相交流供电，供电容易&lt;/li&gt;
&lt;li&gt;无需变频器驱动，成本低廉&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;缺点&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;无法调速&lt;/li&gt;
&lt;li&gt;效率低&lt;/li&gt;
&lt;li&gt;有 100hz 的工频振动&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;再说三相异步电机：&lt;/p&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;功率密度大于单相异步电机&lt;/li&gt;
&lt;li&gt;同功率下成本低于单相电机（有三相供电的情况下）&lt;/li&gt;
&lt;li&gt;转矩恒定，无齿槽转矩波动，无 100hz 工频振动&lt;/li&gt;
&lt;li&gt;便于开环控制&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;无三相电源的情况下，比单相电机要多一个变频器的成本&lt;/li&gt;
&lt;li&gt;效率略低于无刷电机&lt;/li&gt;
&lt;li&gt;功率密度低于无刷电机&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;再说无刷电机：&lt;/p&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;效率高&lt;/li&gt;
&lt;li&gt;功率密度大&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;必须搭配无刷电机驱动器使用，成本高&lt;/li&gt;
&lt;li&gt;无刷电机驱动器成本略高于变频器&lt;/li&gt;
&lt;li&gt;电机有永磁铁，害怕高温&lt;/li&gt;
&lt;li&gt;稀土永磁铁转子成本于鼠笼式异步电机转子&lt;/li&gt;
&lt;li&gt;永磁体带来齿槽转矩波动&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;接着说永磁同步电机：&lt;/p&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;相比无刷电机，齿槽转矩波动小（三相异步电机理论上无转矩波动，实际有一些）&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;效率略低于无刷电机&lt;/li&gt;
&lt;li&gt;正弦波控制器成本高于无刷电机的方波控制&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;我把无刷电机和永磁同步电机单列出来，因为这俩东西看起来差不多，实际也差不多，遵循的也是同样的原理。
但是，还是有较大的差异，主要体现在绕组上。&lt;/p&gt;
&lt;p&gt;无刷电机的绕组一般使用集中式绕组。所谓集中式绕组，指绕组的跨距为1。
集中式绕组跨距小，大大的节约绕组的铜线成本。因为只有嵌入定子槽的铜线才能产生有用的磁场。而在定子槽外面的那部分端线，其磁场是不产生输出的。集中式绕组的端线少，因此成本低。节约的端部铜线成本可以抵消永磁体带来的成本增加。因此无刷电机成本不会大幅高于异步电机，某些情况下可能还低于异步电机。&lt;/p&gt;
&lt;p&gt;但是缺点也是集中式绕组带来的：转矩波动大。&lt;/p&gt;
&lt;p&gt;因此，改用和异步电机一样的长跨距绕组，则可以大大减小转矩波动。于是就是所谓的永磁同步电机了。&lt;/p&gt;
&lt;p&gt;因此永磁同步电机是所有电机类型里成本最高的。&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;接着说控制器。&lt;/p&gt;
&lt;p&gt;只有 异步电机和有刷电机是可以无控制器运行的。无刷电机和永磁同步电机，必须依靠控制器运行。&lt;/p&gt;
&lt;p&gt;单相异步电机如果使用变频器控制，则实际成本（相同的轴功率的情况下）会远高于三相异步电机，因此，如果要搭配控制器，则一定不能考虑单相异步电机。&lt;/p&gt;
&lt;p&gt;异步电机变频器，无刷电机控制器，永磁同步电机控制器，三者都可以运行在无传感器模式和有传感器模式。下面分别列出优缺点。&lt;/p&gt;
&lt;p&gt;其中，算法成本指的就是需要的控制器的运算能力。
控制电路成本指的是为了搭配控制算法而设计的电路的成本。主要是电压电流采样。所有驱动器的功率输出级的成本是一样的。&lt;/p&gt;
&lt;table&gt;
	&lt;thead&gt;
			&lt;tr&gt;
					&lt;th&gt;&lt;/th&gt;
					&lt;th&gt;开环异步&lt;/th&gt;
					&lt;th&gt;无感闭环异步&lt;/th&gt;
					&lt;th&gt;有感闭环异步&lt;/th&gt;
					&lt;th&gt;无感无刷电机&lt;/th&gt;
					&lt;th&gt;有感无刷电机&lt;/th&gt;
					&lt;th&gt;无感永磁同步&lt;/th&gt;
					&lt;th&gt;有传感器永磁同步&lt;/th&gt;
			&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
			&lt;tr&gt;
					&lt;td&gt;需要的传感器&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;脉冲输出转速计&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;霍尔传感器&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;单圈绝对值编码器&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;传感器成本&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;控制算法&lt;/td&gt;
					&lt;td&gt;简单&lt;/td&gt;
					&lt;td&gt;极复杂&lt;/td&gt;
					&lt;td&gt;简单&lt;/td&gt;
					&lt;td&gt;简单&lt;/td&gt;
					&lt;td&gt;简单&lt;/td&gt;
					&lt;td&gt;复杂&lt;/td&gt;
					&lt;td&gt;简单&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;算法成本&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;控制电路成本&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;控制效果&lt;/td&gt;
					&lt;td&gt;够用&lt;/td&gt;
					&lt;td&gt;好&lt;/td&gt;
					&lt;td&gt;极好&lt;/td&gt;
					&lt;td&gt;低速不行&lt;/td&gt;
					&lt;td&gt;极好&lt;/td&gt;
					&lt;td&gt;好&lt;/td&gt;
					&lt;td&gt;好极了&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;转矩波动&lt;/td&gt;
					&lt;td&gt;几乎没有&lt;/td&gt;
					&lt;td&gt;几乎没有&lt;/td&gt;
					&lt;td&gt;几乎没有&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
			&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;其中，无感闭环异步和无感永磁同步，硬件电路成本是最高的。
因为为了达到较好的算法估算效果，需要极高精度的电流和电压采样，并且搭配强悍的 DSP 芯片进行解算。因此实际上是成本大于有感的方案的。只不过某些应用场景下，电机无法安装传感器。例如压缩机内部的驱动电机，其高温高压的环境无法安装传感器。&lt;/p&gt;</description>
    </item>
    <item>
      <title>中国人要反对洋奴哲学</title>
      <link>https://microcai.org/2025/09/09/anti-yangnu.html</link>
      <pubDate>Tue, 09 Sep 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/09/09/anti-yangnu.html</guid>
      <description>&lt;p&gt;作者：张春桥。&lt;/p&gt;
&lt;p&gt;发表于 1976年《红旗》第四期.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;在社会主义革命和建设中，是坚持独立自主、自力更生，还是推行洋奴哲学、爬行主义，这是马克思主义和修正主义两条路线的原则分歧，是社会主义历史阶段两个阶级、两条道路斗争的一个重要方面。 去年夏季前后，党内那个不肯改悔的走资派在“一切为了现代化”的幌子下，又大肆贩卖洋奴哲学。他公开主张把发展生产、发展科学技术的希望寄托在外国，叫嚷“要拿出多的东西换取外国最新最好的设备”，还说什么“这是最可靠的”，而且是“一个大政策”。&lt;/p&gt;
&lt;p&gt;一时，祟洋迷外之风又刮起来了。&lt;/p&gt;
&lt;p&gt;国内劳动群众的创造受到议论讥笑，坚持自力更生的革命精神受到非难攻击，似乎坚持独立自主、自力更生不对了，推行洋奴哲学、爬行主义反而有理了。&lt;/p&gt;
&lt;p&gt;伟大领袖毛主席指出：“自力更生为主，争取外援为辅，破除迷信，独立自主地干工业、干农业，干技术革命和文化革命，打倒奴隶思想，埋葬教条主义，认真学习外国的好经验，也一定研究外国的坏经验——引以为戒，这就是我们的路线。”&lt;/p&gt;
&lt;p&gt;社会的财富是工人、农民和劳动知识分子自己创造的。&lt;/p&gt;
&lt;p&gt;在社会主义制度的基础上，我国人民能够发挥出无穷无尽的力量。只要充分发挥人民群众的聪明智慧和创造才能，完全能够依靠我们自己的力量，建设起一个具有现代农业、现代工业、现代国防和现代科学技术的社会主义强国。&lt;/p&gt;
&lt;p&gt;与此相反，党内机会主义路线的头子总是鼓吹洋奴哲学、爬行主义，推行一条同独立自主、自力更生完全对立的修正主义路线。他们看不见人民群众的力量，根本否认人民群众创造历史这一马克思主义的真理。他们拜倒在西方资产阶级的面前，甘心跟在别人后面一步一步地爬行，甚至主张卖国投降，靠向外国乞讨过活。&lt;/p&gt;
&lt;p&gt;在无产阶级文化大革命运动中，全国人民扬眉吐气，发奋图强，在社会主义建设事业中取得了许多重大的成就。&lt;/p&gt;
&lt;p&gt;人造地球卫星按预定计划返回地面，新的石油勘探开采技术的采用，大型内燃机车、大容量双水内冷汽轮发电机组、百万次电子计算机、电子扫描显微镜、各种类型数控机床等新产品试制成功，都表明我们在赶上和超过世界先进水平的道路上正凯歌行进。&lt;/p&gt;
&lt;p&gt;我们同党内那个不肯改悔的走资派的分歧，并不在于要不要“四个现代化”，而在于走什么道路，执行什么路线，究竟把社会主义建设的基点放在那里。&lt;/p&gt;
&lt;p&gt;毛主席早就指出：“我们的方针要放在什么基点上？放在自己力量的基点上叫做自力更生。”把立足点放在自力更生上，是我们进行革命和建设的一条根本原则，是战胜一切困难夺取胜利的可靠保证。&lt;/p&gt;
&lt;p&gt;在革命战争年代，我们依靠自己的力量，依靠全体军民的创造力，打败了日本帝国主义和国民党反动派。&lt;/p&gt;
&lt;p&gt;在革命战争胜利以后，我们又在物质条件十分困难的情况下，依靠自力更生，打破了帝国主义的封锁禁运，顶住了社会帝国主义的刁难破坏，独立自主地发展社会主义经济，把一个贫穷落后的旧中国，建设成为初步繁荣昌盛的社会主义新中国。&lt;/p&gt;
&lt;p&gt;但是，我们面临的任务仍然是很艰巨的。完成艰巨的任务靠什么？基本的一条就是靠充分动员和依靠广大革命群众。离开这一条，我们就不可能多快好省地建设社会主义。&lt;/p&gt;
&lt;p&gt;因此，我们更要自觉地坚持独立自主、自力更生的方针，绝对不能离开这个基点。&lt;/p&gt;
&lt;p&gt;我们是社会主义国家，又是一个人口众多的大国，我们既不能掠夺别国人民的财富，也不能依赖任何外国的力量来搞建设。吃现成的要受气，依赖别人是建设不成社会主义的。&lt;/p&gt;
&lt;p&gt;只有从本国的实际情况出发，依靠本国人民群众的创造力，充分利用和挖掘本国的资源和潜力，才能在不太长的时间里，建立起独立完整的工业体系和国民经济体系，使我们的国家更能经受风险，立于不败之地。&lt;/p&gt;
&lt;p&gt;党内那个不肯改悔的走资派大唱反调，到处叫嚷要千方百计出口，去“换回好多好东西回来”。据说这样就能加快资源的开发，加快工业的技术改造，加快科研的步伐，真是妙不可言。&lt;/p&gt;
&lt;p&gt;世上难道真有这样的事吗？&lt;/p&gt;
&lt;p&gt;国际上存在阶级斗争，这是不以人们的意志为转移的，工人群众从长期的斗争实践中很懂得这一点，他们说：“我们决不能把社会主义建设的命运系在别人的腰带上”。这句话尖锐地指出要注意被别人卡住脖子，牵着鼻子走的危险。&lt;/p&gt;
&lt;p&gt;如果不把立足点放在自力更生上，样样靠引进，为了引进，甚至把发展经济主要立足于国内市场的社会主义原则丢在一边，无原则地以出口换进口，势必造成那么一种状况：自己能生产的无限制地进口；国内很需要的又无限制地出口；买人家先进的，自己造落后的，甚至把矿山资源的开采主权也让给人家。&lt;/p&gt;
&lt;p&gt;这样下去，岂不是要把我国变成帝国主义国家倾销商品的市场、原料基地、修配车间和投资场所吗？那里还有什么工业化的速度，那里还谈得上独立自主地发展社会主义经济！这只能作帝国主义的经济附庸。&lt;/p&gt;
&lt;p&gt;经济上丧失独立，政治上也就不可能自主。&lt;/p&gt;
&lt;p&gt;中国人民在历史上遭受过的创痛是很深的。&lt;/p&gt;
&lt;p&gt;一百多年前，清朝洋务派头子李鸿章、曾国藩，不就是鼓吹“中国欲自强，则莫如学习外国利器。欲学习外国利器，则莫如觅制器之器”吗？这伙洋奴汉奸，一味想买外国的“制器之器”，搞所谓“自强”。&lt;/p&gt;
&lt;p&gt;结果呢，中国非但没有因此强盛起来，反而越来越深地陷入了殖民地、半殖民地的深渊。&lt;/p&gt;
&lt;p&gt;在社会主义建设中，只有把立足点放在自力更生上，充分发挥人民群众的创造力，才能真正赢得高速度。&lt;/p&gt;
&lt;p&gt;这已经为二十多年来，特别是文化大革命以来的无数事实所证明。我们的石油工业近十五年平均每年增长百分之二十以上，靠的是自力更生，其速度之快，连我们的敌人也无法否认。&lt;/p&gt;
&lt;p&gt;无产阶级文化大革命以来，我们的造船工业的发展速度也很快。&lt;/p&gt;
&lt;p&gt;文化大革命以前，刘少奇宣扬“造船不如买船，买船不如租船”，机引进，船买进，眼睛盯着外国的一点技术专利，国产的货轮和船用柴油机长期得不到发展。&lt;/p&gt;
&lt;p&gt;在文化大革命中，广大工人群众、干部批判了洋奴哲学、爬行主义的修正主义路线，才改变了面貌。&lt;/p&gt;
&lt;p&gt;一九七〇年，上海工人开始打造船工业翻身仗，到一九七五年的六年中，船舶的吨位和柴油机的马力都超过了文化大革命前十七年的总和。&lt;/p&gt;
&lt;p&gt;文化大革命前只造了一艘万吨轮，而这六年中万吨级以上的船舶就造了四十四艘。到底是自力更生快，还是搞洋奴哲学快，不是很清楚吗？&lt;/p&gt;
&lt;p&gt;党内那个不肯改悔的走资派口口声声说要把国民经济搞上去，却偏偏闭住眼睛不看事实，真是偏见比无知离真理更远！&lt;/p&gt;
&lt;p&gt;搞社会主义，首先要坚持正确的方向和道路。&lt;/p&gt;
&lt;p&gt;党内那个不肯改悔的走资派，打着把国民经济搞上去的旗号，到处鼓吹只要拿到先进的技术、设备，不管走什么路，用什么方法都可以。&lt;/p&gt;
&lt;p&gt;毛主席最近指出：“他这个人是不抓阶级斗争的，历来不提这个纲。还是‘白猫、黑猫’啊，不管是帝国主义还是马克思主义。”&lt;/p&gt;
&lt;p&gt;按照党内那个不肯改悔的走资派的一套办，必然把我国经济引向资本主义道路。其实，即使是资本主义国家，完全依靠外国，也不可能真正发展自己的独立经济。&lt;/p&gt;
&lt;p&gt;我们是社会主义国家，要有自己的独立的经济体系，只能走自己工业发展的道路。离开独立自主、自力更生，不但搞不成社会主义的现代化，而且会使我们的社会主义国家蜕化变质，复辟资本主义，靠向外国乞讨过活。&lt;/p&gt;
&lt;p&gt;苏修就是一面镜子。苏联全面复辟资本主义之后，官僚垄断资本向西方垄断资本买专利权，借贷款，甚至不惜把未开发的资源拿去作抵押。自称有强大工业基础的超级大国，外债却越背越重，从一九六四年到一九七五年上半年，向西方国家乞求贷款竟达一百六十叁亿美元。一手向人家掠夺，一手又向人家乞讨，这是苏修叛徒集团搞假共产主义的一大特色。&lt;/p&gt;
&lt;p&gt;我们提倡自力更生，并不是拒绝学习和研究外国的经验，包括好的经验和坏的经验。我们也不是反对引进某些确实有用的外国技术、设备。但是，对待外国的经验以及技术、设备，都要具体分析，加以鉴别，“排泄其糟粕，吸收其精华”，使其为我所用。学习要和独创结合，立足予超。决不能生吞活剥地照抄照搬，不管好的和坏的、成功的和失败的，适合我国需要的和不适合我国需要的，一古脑儿统统搬来。&lt;/p&gt;
&lt;p&gt;毛主席历来号召我们，要破除迷信，解放思想，埋葬教条主义，打倒奴隶思想，批判那种认为“外国月亮比中国的圆”的洋奴哲学。因为这些东西是窒息人民群众的革新创造精神、束缚人民群众手脚的精神枷锁。洋教条、洋偶像不扫荡，生动活泼的革命精神就焕发不出来。&lt;/p&gt;
&lt;p&gt;那些盲目崇拜外国的人，看不起本国人民群众的智慧和力量，在“洋”人面前矮半截，以为事事不如人，连某些资产阶级思想家都不如。&lt;/p&gt;
&lt;p&gt;清代的学者严复就很赞赏“学我者病，来者方多”的说法，不主张生搬硬套，懂得后来可以居上的道理。&lt;/p&gt;
&lt;p&gt;我们不能走世界各国技术发展的老路，跟在别人后面一步一步地爬行。&lt;/p&gt;
&lt;p&gt;我们要敢于走前人没有走过的道路，敢于攀登前人没有攀登过的高峰。&lt;/p&gt;
&lt;p&gt;外国有的，我们要有；外国没有的，我们也要有。&lt;/p&gt;
&lt;p&gt;文化大革命以来，许多工厂试制成功的新产品、新材料，有不少就是工人群众发奋图强、土法上马搞出来的。工人们豪迈地说：西方资产阶级能办到的，东方无产阶级也一定能办到。而且办得更好；西方资产阶级办不到的，我们东方的无产阶级也能办到。&lt;/p&gt;
&lt;p&gt;党内那个不肯改悔的走资派却把中外资产阶级的东西奉若神物，对于我国人民群众的创造从来看不上眼，只许永远跟着别人爬行。&lt;/p&gt;
&lt;p&gt;洋奴哲学、爬行主义有着深刻的阶级根源和思想根源。中国的买办资产阶级从来是帝国主义的附庸，历来奉行洋奴哲学。民族资产阶级先天就有软弱性，既怕民众，也怕帝国主义。它同帝国主义有矛盾的一面，在一个时期里有可能与民众结成统一战线去反对帝国主义，但它又有依附于帝国主义经济的一面，常常屈服于帝国主义的压力，崇洋迷外。&lt;/p&gt;
&lt;p&gt;党内走资本主义道路的当权派是党内的资产阶级。 在民主革命阶段，他们就是带着资产阶级的这种劣根性跑进党内来的。进入社会主义革命时期，没有把立足点移过来，仍然代表资产阶级。他们害怕群众、害怕帝国主义的劣根性愈来愈发作，就不能不同广大人民群众处于尖锐对立的地位。&lt;/p&gt;
&lt;p&gt;阶级投降和民族投降是一对孪生兄弟。对内搞阶级投降，对外必然要搞民族投降，鼓吹洋奴哲学。 洋奴哲学，是帝国主义长期侵略我国的精神产物。只要阶级和阶级斗争还存在，只要帝国主义还存在，洋奴哲学的幽灵总会在一部分人的头脑中徘徊。&lt;/p&gt;
&lt;p&gt;因此，批判洋奴哲学，是个长期的斗争任务，必须反复地进行下去。我们一定要遵照毛主席的教导，以阶级斗争为纲，深入批判洋奴哲学，更加自觉地坚持独立自主、自力更生的方针，加速我国社会主义建设的步伐，把无产阶级专政下的继续革命进行到底。&lt;/p&gt;</description>
    </item>
    <item>
      <title>了解反激，驯服反激</title>
      <link>https://microcai.org/2025/05/24/flyback-howto.html</link>
      <pubDate>Sat, 24 May 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/05/24/flyback-howto.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;反激，这恐怕是当今世上使用最广泛的开关电源拓扑了。&lt;/p&gt;
&lt;p&gt;学习电力电子技术，就从反激开始。&lt;/p&gt;
&lt;h1 id=&#34;何谓反激&#34;&gt;何谓反激&lt;/h1&gt;
&lt;p&gt;反激反激，顾名思义，是反过来激发。啥叫反过来呢？意思就是，开关管关闭的时候，变压器才开始干活。开关管关闭了，变压器主绕组上都没电流了，变压器才开始干活。
这没电流了才想起来该干活了，所以是反着的。故得名反激。有反必有正，故而必有一个正激来对应。&lt;/p&gt;
&lt;h2 id=&#34;为何要反过来干活&#34;&gt;为何要反过来干活&lt;/h2&gt;
&lt;p&gt;其实开关电源最先诞生的拓扑绝对不是反激。可能是正激，也可能是推挽。&lt;/p&gt;
&lt;p&gt;正激变压器其实更容易理解，因为他就是按照变压器的定义工作的。正激变换器拓扑可以看成是隔离版的 Buck 降压电路。&lt;/p&gt;
&lt;p&gt;所以，反激也可以看成是隔离版的Boost升压电路。&lt;/p&gt;
&lt;p&gt;因为，反激和 Boost 升压的一个共同点是，都是在开关管关断的时候，才能对外输出能量。&lt;/p&gt;
&lt;p&gt;因此，反激之所以要反过来干活，其实他脱胎自 boost 升压电路。&lt;/p&gt;
&lt;p&gt;在 Boost 变换器里，开关管打开的时候，输出二极管截止。输入电压全部施加在电感上，对电感进行充能。随着时间推移，电感上的电流越来越大。
如果电流大到突破电感的饱和值，电感就会突然失去电感特性，变成一条导线，于是短路炸机。好在，控制器不会允许电感电流突破饱和值，而是适时的关闭 开关管。
因为电感电流不能突变，因此电感的电流需要寻找突破口继续流动。于是就会击穿 输出二极管，对输出电容进行充电。直到开关管下一次打开。下一次打开前，电感电流要么已经归0,要么还有剩余电流。&lt;/p&gt;
&lt;p&gt;而在 反激变换器里，其实这个过程由变压器的两个绕组分别在不同的时间不同的空间完成。
开关管打开的时候，次级的二极管截止，次级线圈没有电流。输入电压全部施加在初级线圈上，对变压器进行充能。随着时间推移，初级线圈上的电流越来越大。
如果电流大到突破变压器磁芯的饱和值，变压器就会突然失去感抗，变成一条导线，于是短路炸机。好在，控制器不会允许初级线圈电流突破饱和值，而是适时的关闭 开关管。&lt;/p&gt;
&lt;p&gt;但是此时，电感电流不能突变的定律就不再适用了。其实电感电流不能突变不是铁律，真正的铁律是磁通量不能突变。为了维持磁通量不变，电感的电流才不能突变。
如果铁芯上绕有2个绕组，那么另一个绕组立即产生电流，也可以维持磁通量不变。&lt;/p&gt;
&lt;p&gt;而次级绕组上的二极管，恰恰会在初级的开关管关闭的时候，允许电流通过了。于是，为了维持磁通量不变，次级立即会产生 N倍于初级关管时刻电流的电流。这个 N 取决于变压器线圈的匝比。
这就是所谓的 安匝平衡。&lt;/p&gt;
&lt;p&gt;所以，反激和 Boost 升压的一个改进之处，是它输出有了一个N倍的电流放大，这导致了输出有了 N 倍的电压下降。于是反激相比 boost 升压电路，反而可以因为这个变比实现降压。
然后是输出又另一个线圈完成，于是输入输出就电气隔离了。&lt;/p&gt;
&lt;h2 id=&#34;相比正激的优势&#34;&gt;相比正激的优势&lt;/h2&gt;
&lt;p&gt;任何变压电路，都需要电感的参与。正激是隔离版的 Buck 。但是，他的变压器不是电感。他的变压器只是实现了电流的比例变换。变换后，还需要电感“续流”才能实现完整的回路。&lt;/p&gt;
&lt;p&gt;也就是说，在正激变换器里，变压器+开关管，只是实现了非隔离 Buck 电路里的 “开关管” 的功能。另一个电感，还需要存在以维持开关管关闭的时候的输出。&lt;/p&gt;
&lt;p&gt;所以，在正激变换器里，需要一个变压器变压，同时输出还需要有一个电感。&lt;/p&gt;
&lt;p&gt;而反激变换器里，变压器同时承担电流放大和电感的功能。因此，反激变换器相比正激最大的意义，就是省去了一个输出侧的电感。&lt;/p&gt;
&lt;p&gt;从而极大的降低了成本。&lt;/p&gt;
&lt;h2 id=&#34;反激的劣势&#34;&gt;反激的劣势&lt;/h2&gt;
&lt;p&gt;反激的优势是便宜，而劣势则是漏感带来的能量损耗。理想的变压器当然没有漏感。然而现实中的变压器有。
意味着初级的开关管关断的时候，并不能100%的将能量转移到次级。&lt;/p&gt;
&lt;p&gt;这部分不能转移到次级的能量，继续推动初级线圈的电流运动。然而此时开关管已经关断，于是电感的电流没有续流路径，反而会形成一个尖峰电压加在开关管上。
为了吸收这部分能量保护开关管，就需要一个由电容电阻构成的吸收电路，通过发热消耗掉漏感能量。&lt;/p&gt;
&lt;p&gt;因此，反激的第一个劣势，就是变压器漏感一定会产生能量损耗。这部分损耗和初级线圈电流的平方成正比，和初级的漏感成正比。&lt;/p&gt;
&lt;p&gt;电流越大，漏感导致的能量损失就越大。&lt;/p&gt;
&lt;p&gt;因此反激一定要限制初级的峰值电流。也就限制了整个电源的功率不能太大。&lt;/p&gt;
&lt;h1 id=&#34;元件参数的计算&#34;&gt;元件参数的计算&lt;/h1&gt;
&lt;p&gt;在反激变换器里，最关键和最难的是变压器参数的计算。&lt;/p&gt;
&lt;p&gt;反激的变压器，不单单是变压器，他还是电感。因此，反激的变压器，不能只看匝数。还得看电感。&lt;/p&gt;
&lt;p&gt;因此，反激变换器里，变压器的几个关键参数需要设计阶段进行抉择：&lt;/p&gt;</description>
    </item>
    <item>
      <title>记录使用 GP8891CAS 时踩的一个天坑</title>
      <link>https://microcai.org/2025/05/13/a-trap-by-gp8891cas.html</link>
      <pubDate>Tue, 13 May 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/05/13/a-trap-by-gp8891cas.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;任何一个家电，必须得有一个低压供电电源。&lt;/p&gt;
&lt;p&gt;要获得一个低压供电，通常的做法是接一个开关电源。&lt;/p&gt;
&lt;p&gt;但是，外置的电源徒增成本。而且显得很不专业。最好的办法就是在 PCB 上集成一个供电电源。&lt;/p&gt;
&lt;p&gt;想起来前年我刚刚入门硬件设计。做了一个 低压变频器。
到去年年初的时候，开始尝试制作 220V 市电版的变频器。事情见 &lt;a href=&#34;https://microcai.org/2024/02/05/220v-vfd-success.html&#34;&gt;这片文章&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;那时候，我是不懂 ACDC 变换的。因此电路板上低压供电，是由电源模块实现的。&lt;/p&gt;
&lt;p&gt;比如当时的照片&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-02-08_13-22-33.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;可以看到 画面中有2个 电源模块的位置。&lt;/p&gt;
&lt;p&gt;没错，还得用俩电源模块。分别供应高压侧的栅极驱动，和低压侧的单片机。&lt;/p&gt;
&lt;p&gt;而且还分别是 220V转 12V 和 220V 转5V 。虽然两个模块并不贵。三块多一个。但是，加起来也有七块钱了。&lt;/p&gt;
&lt;p&gt;而且还让我的设计不紧凑，使用了外挂电源模块。显得很不高级。&lt;/p&gt;
&lt;p&gt;后来，我改进了设计。因为我绘制低压的时候，经常就使用 32V转5V的 DCDC 电路。&lt;/p&gt;
&lt;p&gt;因此，我使用了 DK501 这款能直接从 DC310V 经过 Buck变换降压到 12V 的芯片。&lt;/p&gt;
&lt;p&gt;还是熟悉的 Buck 电路。&lt;/p&gt;
&lt;p&gt;但是， Buck 降压是非隔离的。为了给单片机供一个隔离的电，我还是使用了一个 12V转5V的隔离电源模块。&lt;/p&gt;
&lt;p&gt;这样让板子的外挂电源从2个变成了1个。。。。&lt;/p&gt;
&lt;h1 id=&#34;flybuck-方案&#34;&gt;FlyBuck 方案&lt;/h1&gt;
&lt;p&gt;我发现，要设计好电路，一定要先学会电源。没有电源任何事情都办不成。
于是我开始在看 B站上长江大学的唐老师的视频。唐老师是长江大学的老师，专门教电源电路的。他出了几百期视频，大部分就是在讲解 Buck/Boost/SEPIC 这类 DCDC 电路。&lt;/p&gt;
&lt;p&gt;看了几百期视频，我才了解到，有一种廉价的隔离电源的方案，叫 FlyBuck 。 就是把 buck 电路的电感换成2个绕组的共模电感。&lt;/p&gt;
&lt;p&gt;这样在共模电感的另一个线圈，就能直接获得一个同样电压的隔离供电。&lt;/p&gt;
&lt;p&gt;于是，这就是我后来改进的方案了。后来这个方案被用在了 ACBuck 电路里。&lt;/p&gt;
&lt;p&gt;ACBuck 使用 DK501 从 整流后的 310V 直流电直接 BUCK 降压到 12V, 但是，使用的 flybuck, 偷偷的把电感换成了共模电感。于是在主回路获得非隔离的 12V, 在另一个绕组获得隔离的 12V。
然后 12V 经过降压获得 3.3v 给单片机使用。&lt;/p&gt;</description>
    </item>
    <item>
      <title>设计一个 3V - 100V 超宽压输入，15V 输出的电源</title>
      <link>https://microcai.org/2025/05/02/boost-as-flyback.html</link>
      <pubDate>Fri, 02 May 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/05/02/boost-as-flyback.html</guid>
      <description>&lt;h1 id=&#34;dcdc-的困境&#34;&gt;DCDC 的困境&lt;/h1&gt;
&lt;p&gt;在设计一个电机控制器的时候，遇到了一个多电压的问题。&lt;/p&gt;
&lt;p&gt;首先是单片机，需要 3.3V 供电。然后是传感器，需要 5V 供电，最后是栅极驱动，需要 15V （其实是 10-18V 都行 ）供电。&lt;/p&gt;
&lt;p&gt;如果使用降压 DCDC 的方式获得这些电压，意味着这个电机控制器，最低需要 15V 供电。&lt;/p&gt;
&lt;p&gt;这样，就不能适应广泛存在的电压标准：12V。因此，使用降压的方式获得这些电压，通常意味着设计输入电压为 24V 和以上。&lt;/p&gt;
&lt;p&gt;如果是 12V供电，则需要升压到 15V。如果想实现同时支持 12V 和  24V 供电，做法有两个。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;- 使用 升降压 方案。需要4个MOS管，成本略高。

- 输入先降压到 5V, 然后升压到 15V。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;降压后升压或者升降压的方案，意味着板子可以支持 6V 12V 24V 三个电压等级的应用。&lt;/p&gt;
&lt;p&gt;但是，如果是单锂电池供电呢？则需要支持到 3V 输入。如果先降压到 3V, 则3V 到 15V 的升压倍数较大。Boost 变换会较为吃力。
可以先选择升压。3V 先升压到 16V。 然后 从 16V 降压到哦 15V 和 5V。如果输入超过 16V ， 则前级的 Boost 芯片停止工作，直通到后面的 降压 15V 的芯片。&lt;/p&gt;</description>
    </item>
    <item>
      <title>直流 UPS 功能的电源</title>
      <link>https://microcai.org/2025/04/24/ups-flyback.html</link>
      <pubDate>Thu, 24 Apr 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/04/24/ups-flyback.html</guid>
      <description>&lt;h1 id=&#34;恒流恒压模式和电池的充电原理&#34;&gt;恒流恒压模式和电池的充电原理&lt;/h1&gt;
&lt;p&gt;开关电源分恒压模式，和恒流恒压模式两种。区别就在于，负载消耗的电流超过了电源的供电能力时电源的应对策略。 恒压电源会立即切断输出进入保护模式。可能可以经过一段时间的等待后重新打开输出。即 “打嗝模式”。而恒流恒压模式下，电源会减小输出电压，直到负载消耗的电流小于设定值。适用于负载电流会随着电压的降低而降低的情况使用。例如，充电。&lt;/p&gt;
&lt;p&gt;电池是一个电压源，它自身的内阻极小。因此，如果外部电压低于电池，电池就会放电，以稳定电压。如果外界电压高于电池，电池则会充电，以稳定电压。
充电电流的大小，可以用 （电源电压-电池电压）/电池内阻 计算。而电池的内阻极小，电压会随着充电进行逐步提升，因此充电器需要有“恒压恒流”模式。&lt;/p&gt;
&lt;p&gt;首先输出电池的满电电压，然后设定一个最大的电流。和电池并联后，开关电源的电压大于电池电压（除非是满电状态）再加上电池内阻很小，充电器会输出一个很大的电流。此时充电器立即进入恒流模式。降低输出电压，直到电流等于设定的电流就不再降低电压。&lt;/p&gt;
&lt;h1 id=&#34;同时并联运行负载和对电池充电&#34;&gt;同时并联运行负载和对电池充电&lt;/h1&gt;
&lt;p&gt;如果负载消耗的是 直流电，那么将电池逆变成 220v 然后再由负载的电源转换为直流电，这对电池存储的能量无疑是巨大的浪费。而且电池的容量非常昂贵。因此，在低压系统里，最佳的 UPS 实践方法，是直接并联一组 12V 电池进行供电。当开关电源的输出消失，就是电池立即填补输出的时候。&lt;/p&gt;
&lt;p&gt;但是，在 直接并联电池当 UPS 的12V 低压供电系统里，如果使用 12v 恒流恒压电源直接对负载供电并且并联一个电池，则无法控制电池的充电电流。
只要电池未进入涓流充电模式，那么电池总是倾向于吃完电源的输出电流。迫使电源进入恒流模式。
因此，充电电流总是会被动的设置为 充电器的输出电流 - 负载消耗电流。
如果负载消耗的电流是一个定数，倒是可以设定 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mtext&gt;充电器的输出电流&lt;/mtext&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mtext&gt;负载消耗的定数电流&lt;/mtext&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mtext&gt;期望的充电电流。&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;充电器的输出电流 = 负载消耗的定数电流 + 期望的充电电流。&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;然而，现实中，负载的电流消耗总是波动的。而如果负载消耗电流波动较大，例如负载最大可消耗 10A 电流的情况下，就需要设置恒流 10A输出。这意味着电池最大必须接受 10A 的充电电流。必须假定负载有可能不消耗任何电流。而如果不配置 10A 的充电器，那么可能会在极端情况下，即使没有停电也会导致电池越用越没电。&lt;/p&gt;
&lt;p&gt;因此，我们需要设计一种特殊的充电器，它只有一路 12V 输出，电池和负载并联到一起。但是却可以同时监控负载和电池的电流。总输出进行恒压恒流模式的同时，对冲入电池的电也加恒压恒流模式。
它的输出电压会维持在恰好满足负载的供电，并且对电池进行恒流恒压模式充电。也就是说，如果设定充电电流为 1A 。那么充电器会恰好输出电压使得电流 = 1A + 负载消耗电流。如果电池已经进入恒压充电阶段，则正好输出电池满电电压。即便负载的电流从 0A 到 10A 变化，也不会用更大的电流对电池充电。
这样的 UPS ，在电池亏电的情况下，就不会盲目的以最大电流模式输出，以期电池能吸纳剩余电流。也不需要特意配置一个小功率充电器限制电池充电电流又导致极端下电池边充边掉电。
而是可以恰到好处的按设定电流充电，而不管充电器本身的电流输出能力是多少。&lt;/p&gt;
&lt;h1 id=&#34;实现原理&#34;&gt;实现原理&lt;/h1&gt;
&lt;p&gt;UPS 的原理是：
充电器为两路并联的 12V 输出。2个输出在内部是并联的，由同一个变压器绕组供电。
电池和输出实际上是并联的，因此停电后，电池会立即放电为负载供电。中间没有任何切换延迟。&lt;/p&gt;
&lt;p&gt;同时进行电池限流的原理是：&lt;/p&gt;
&lt;p&gt;输出虽然是并联的，但是使用了2个采样电阻分别采样两路输出的电流大小。
整个电源的输出部分，就有 恒压反馈，负载恒流反馈，电池恒流反馈，这三个负反馈控制环路。&lt;/p&gt;</description>
    </item>
    <item>
      <title>变频器原理和设计指导</title>
      <link>https://microcai.org/2025/04/19/vvvf-explained.html</link>
      <pubDate>Sat, 19 Apr 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/04/19/vvvf-explained.html</guid>
      <description>&lt;h1 id=&#34;从-buck-降压电路说起&#34;&gt;从 Buck 降压电路说起&lt;/h1&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/basic_buck.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;上图为一个基本的 Buck 降压电路。 Q1 和 Q2 是互补的两个 MOS/IGBT 管。&lt;/p&gt;
&lt;p&gt;所谓互补，是两个同时只有一个会导通。要么是 Q1 打开，要么是 Q2 打开。&lt;/p&gt;
&lt;p&gt;Q1 关闭的时候， Q2 必须打开。Q1 打开的时候，Q2 必须关闭。&lt;/p&gt;
&lt;p&gt;Q1 和 Q2 可以使用一个 PWM 信号控制。&lt;/p&gt;
&lt;p&gt;那么 pwm 信号的占空比，就决定了 Q1 打开的时间占比。也就决定了 OUTPUT 输出端的电压占 总 电压的比。&lt;/p&gt;
&lt;p&gt;OUTPUT 处的电压 = VCC * pwm 占空比。&lt;/p&gt;
&lt;p&gt;记住这个。&lt;/p&gt;
&lt;h1 id=&#34;两路-buck-降压电路&#34;&gt;两路 Buck 降压电路&lt;/h1&gt;
&lt;p&gt;将上述降压电路复制成2份，就构成了一个逆变器。&lt;/p&gt;
&lt;p&gt;为何呢？&lt;/p&gt;
&lt;p&gt;看图&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/buck_as_H_bridge.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;两个 Buck 电路，输出 OUTPUTA 和 OUTPUTB 。&lt;/p&gt;
&lt;p&gt;如果 OUTPUTA 的电压 &amp;gt; OUTPUTB 的电压。那么对于接到 OUTPUTA和OUTPUTB的负载来说，电流就会从 OUTPUTA流出，经过负载后，流入 OUTPUTB.&lt;/p&gt;
&lt;p&gt;如果 OUTPUTA 的电压 &amp;lt; OUTPUTB 的电压。那么对于接到 OUTPUTA和OUTPUTB的负载来说，电流就会从 OUTPUTB流出，经过负载后，流入 OUTPUTA.&lt;/p&gt;</description>
    </item>
    <item>
      <title>防启动浪涌电流设计</title>
      <link>https://microcai.org/2025/04/19/surge-avoid-startup.html</link>
      <pubDate>Sat, 19 Apr 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/04/19/surge-avoid-startup.html</guid>
      <description>&lt;h1 id=&#34;启动浪涌&#34;&gt;启动浪涌&lt;/h1&gt;
&lt;p&gt;在许多用电设备里，都要配置一个巨大的储能稳压电容。&lt;/p&gt;
&lt;p&gt;这个大电容会在设备启动的瞬间，吸收巨大的充电电流。形成浪涌。&lt;/p&gt;
&lt;p&gt;为了避免浪涌电流，需要限制充电电流。一个典型的做法是使用 NTC 电阻。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ntc_inruash_avoid.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;NTC 电阻初始电阻较高。工作一段时间后电阻值下降。这样就以较低的成本解决了开机浪涌电流。&lt;/p&gt;
&lt;p&gt;但是 NTC 毕竟不是导线，高温下电阻仍然有一些。对效率不利。
而且关机后立马插电开机，则 NTC 温度较高，当时电容却是空的。此时防止不了浪涌。&lt;/p&gt;
&lt;p&gt;因此，通常的做法是使用继电器防浪涌。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/inrush_current_avoid_relay.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;插入插头的时候， 外部电源通过 R3 电阻 对 C1 充电。&lt;/p&gt;
&lt;p&gt;等 C1 充满后，Q1 打开，继电器吸合，旁路掉启动电阻。&lt;/p&gt;
&lt;p&gt;不过，都用上继电器了，使用 单刀双掷的继电器其实并不增加成本，反而还可以多一个功能：下电自动进行电容泄放。&lt;/p&gt;
&lt;p&gt;如图：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/inrush_current_avoid_relay2.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;一开始，继电器3 5 脚常闭。 2 5 脚常开。&lt;/p&gt;
&lt;p&gt;于是，上电后，电源通过 R3 对 C1 充电。&lt;/p&gt;
&lt;p&gt;C1 充满后，控制信号控制 MOS 导通，导致继电器吸合。 继电器的 3 5 脚断开， 2 5 脚闭合。&lt;/p&gt;
&lt;p&gt;这样 R3 就被继电器旁路了。&lt;/p&gt;
&lt;p&gt;断电后，继电器由于停电自动断开。 2 5 脚断开，3 5 脚自动闭合。&lt;/p&gt;
&lt;p&gt;此时 C1 电容通过 R4 电阻进行释放。&lt;/p&gt;
&lt;p&gt;也就是，实现了掉电自动对 C1 进行释放的机制。&lt;/p&gt;</description>
    </item>
    <item>
      <title>DMA 大幅降低 SVPWM/SPWM 调制的 CPU 占用</title>
      <link>https://microcai.org/2025/04/14/use-dma-to-reduce-spwm-overhead.html</link>
      <pubDate>Mon, 14 Apr 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/04/14/use-dma-to-reduce-spwm-overhead.html</guid>
      <description>&lt;h1 id=&#34;svpwm-和-dma&#34;&gt;S(V)PWM 和 DMA&lt;/h1&gt;
&lt;p&gt;在变频器里，FOC 通常使用 定时器 输出 PWM 实现。&lt;/p&gt;
&lt;p&gt;通常来说，需要在每个 PWM 的益出中断里，重新计算三路输出的 PWM 占空比。&lt;/p&gt;
&lt;p&gt;如果使用非常高的pwm频率，那么 pwm 的中断将非常频繁。这对于 cpu 时钟并不高的单片机来说，会极大的降低 cpu 处理其他业务逻辑的能力。&lt;/p&gt;
&lt;p&gt;而这个问题，在使用 &amp;ldquo;同步调制&amp;rdquo; 的方式下，有一个很好解决的办法。&lt;/p&gt;
&lt;p&gt;在同步调制下，载波频率随着输出的频率变化而变化。这意味着，pwm 的占空比实际上是周期性发生的。&lt;/p&gt;
&lt;p&gt;比如使用 1:360 的同步调制下，每个 sin基波由 360个pwm方波构成。意味着，每隔 360 次，pwm 占空比就会重复。&lt;/p&gt;
&lt;p&gt;因此，如果预先分配一个 360 份的 pwm占空比。然后使用 DMA 搬运 pwm占空比到 TIM 定时器。则整个 spwm 过程中， cpu 都不再需要参与。&lt;/p&gt;
&lt;p&gt;如果需要改变输出频率，则 cpu 只须调节 pwm 的频率，甚至不需要更新 DMA 的数据。&lt;/p&gt;
&lt;p&gt;直到 pwm 频率已经不适应输出频率，直到发生“换挡” &amp;mdash; 切换调制比。&lt;/p&gt;
&lt;p&gt;每次切换调制比的时候，就需要重新生成 pwm占空比序列，然后重新设置 DMA 控制器。&lt;/p&gt;
&lt;p&gt;而且，三个 pwm 通道可以使用同一份 pwm 占空比循环数据。只要初始运行的时候，使用不同的起始地址。&lt;/p&gt;</description>
    </item>
    <item>
      <title>简谐运动 和 CNC 运动插补</title>
      <link>https://microcai.org/2025/03/07/sin-in-cnc.html</link>
      <pubDate>Fri, 07 Mar 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/03/07/sin-in-cnc.html</guid>
      <description>&lt;h1 id=&#34;数控机床的基础知识&#34;&gt;数控机床的基础知识&lt;/h1&gt;
&lt;p&gt;机床每个轴的伺服电机，期望输入的是步进信号：一个脉冲信号和一个方向信号。&lt;/p&gt;
&lt;p&gt;因此，机床的运动控制器，需要将程序中的移动指令，转换为多个轴的步进信号。&lt;/p&gt;
&lt;p&gt;例如一个分辨率为 0.001mm 的机床，控制器每发送一个脉冲信号，电机就旋转一个小角度，通过传动系统后，体现为主轴移动了 0.001mm。&lt;/p&gt;
&lt;p&gt;对多轴联动机床来说，程序中的移动指令，要被控制器分解为多个轴的移动。然后控制器需要精确的控制每个轴的步进信号，使得多个轴可以协调运动，完成所谓的多轴联动。&lt;/p&gt;
&lt;p&gt;例如程序指令是将主轴从 (0,0,0) 坐标移动到 （0.1,0.2,0.3）。那么控制器需要在 X 轴发送 100 个脉冲，Y 轴发送 200 个脉冲，Z 轴发送 300 个脉冲。&lt;/p&gt;
&lt;p&gt;不仅仅是要发送这几个脉冲，而且要确保，这几个脉冲的间隔时间正好是 3:2:1 , 于是 X 轴发送 100 个脉冲，Y 轴发送 200 个脉冲，Z 轴发送 300 个脉冲 花费的时间恰好相等，这样，机床主轴在伺服电机的驱动下，就可以让主轴沿着直线从  (0,0,0) 坐标移动到 （0.1,0.2,0.3）。&lt;/p&gt;
&lt;p&gt;过去，数控机床只能实现两轴联动。例如 将主轴从 (0,0,0) 坐标移动到 （0.1,0.2,0.3），机床需要分解成2个步骤执行。
首先抬起主轴，也就是 将主轴从 (0,0,0) 坐标移动到 （0,0,0.3）。 接着移动主轴到 （0.1,0.2,0.3）。无法实现三个轴同时运动。&lt;/p&gt;
&lt;p&gt;这种机床，现在已经非常罕见了。人们形象的称呼其为  2.5轴机床。因为物理上有三个轴，但是只能2个轴实现联动。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不过控制器限制下的 2.5 轴机床虽然少见，但是将3轴机床当 2.5轴使用却还是主流。比如 3D 打印，就几乎只需要两轴联动。虽然实际上它的控制器是完全支持3轴联动的。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;为了加工复杂曲面，机床会额外引入 3个旋转轴中的2个。三个旋转轴记为是 A B C 轴，分别对应在 X Y Z 轴上的旋转。由于主轴的刀具自身就在旋转，因此通常 主轴所在的轴是无意义。因此只需要2个旋转轴。通常主轴是在 Z 轴上，因此一般而言立式加工是 A B 两个旋转轴，而卧式加工的主轴是水平放置的，因此通常会使用 A C 轴 或者 B C 轴。&lt;/p&gt;</description>
    </item>
    <item>
      <title>极坐标在三相电力系统中的计算优势</title>
      <link>https://microcai.org/2025/02/26/polar-coordinate-system-for-3phase-power.html</link>
      <pubDate>Wed, 26 Feb 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/02/26/polar-coordinate-system-for-3phase-power.html</guid>
      <description>&lt;p&gt;在三相电力系统里，我们有三个相位差 120° 的火线。于是，也就有了三个相位差120°的电压和电流矢量。&lt;/p&gt;
&lt;p&gt;三相平衡的前提下。对这个三相的电压电流矢量进行计算的时候，为了方便计算，会用到 park 和 clark 变换。目的是转成2个互相垂直的矢量。需要考虑的矢量个数，就从3个降到了2个。&lt;/p&gt;
&lt;p&gt;但是，如果引入 极坐标系统，那么三相平衡的前提下，这3个电压矢量，就可以在极坐标下，合成为一个电压矢量。3个电流矢量，在极坐标系下就可以合成为一个电流矢量。&lt;/p&gt;
&lt;p&gt;并且二者可以使用同一个坐标系。不需要专门引入一个旋转的坐标系。当然，就算要引入旋转坐标系，在极坐标系体系里，在原点旋转只需要一个加法。因为在三相平衡的条件下，电压和电流矢量都是从原点开始的。&lt;/p&gt;
&lt;p&gt;在极坐标下，三相电压可以描述为  （ Vmax ，θv）。其中 Vmax 是相电压最大值，而 θv 为相位。
同理，三相对称电流也可以描述为 （Imax, θi）。其中 Imax 是相电流的最大值。而 θi 为相位。&lt;/p&gt;
&lt;p&gt;虽然最终用于描述的变量都是2个。在 直角坐标系下，经过 clark 变换后， 电压也是描述为 (Ualpha , Ubeta)。
但是极坐标体系对计算过程更友好了。&lt;/p&gt;
&lt;p&gt;比如，判定功率因素，只需要将 电压和电流的 相位相减，然后求余弦即可。
比如，计算有功功率，&lt;code&gt;Vmax*Imax*cos(θv - θi)。&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;在 foc 的控制中，我们主要的控制目标，就是 让 &lt;code&gt;θi - θe = 90°&lt;/code&gt;。其中， θe 为转子的电角度。控制方式为调整 θv 相对 θe 的提前量。范围是 (θv - θe) ∈ [90°， 180°)。 本环应该采取慢速环。控制带宽应该低于电机的转动惯量。以免电流测量带来的 θi 高频波动影响 θv。&lt;/p&gt;
&lt;p&gt;其次对扭矩的控制，我们主要控制 Imax = Iref 即可。而电流属于间接控制。其内环是 电压环。
电压环的控制目标，就是 Vmax。控制 Vmax = Vref 即可。&lt;/p&gt;</description>
    </item>
    <item>
      <title>三相220v供电可行性再论</title>
      <link>https://microcai.org/2025/02/11/220v-3phase-again.html</link>
      <pubDate>Tue, 11 Feb 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/02/11/220v-3phase-again.html</guid>
      <description>&lt;p&gt;经过深思熟虑，我提出了一种新的居民用电供电模式： 即三相220伏4线制供电。以适应未来更大的入户功率需求。&lt;/p&gt;
&lt;p&gt;特点为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;- 入户线路为3根火线，一条地线，没有零线。
- 火线和火线之间的电压为220v。火线对地电压 130v。
- 入户电表设计三相不平衡保护开关
- 使用任意2条火线来兼容老的单相220v设备，继续提供 220v 的 2孔和3孔插座。
- 三相设备使用4脚插座。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不同供电制度下的对比如下：&lt;/p&gt;
&lt;table&gt;
	&lt;thead&gt;
			&lt;tr&gt;
					&lt;th&gt;&lt;/th&gt;
					&lt;th&gt;220v三相&lt;/th&gt;
					&lt;th&gt;220v 单相&lt;/th&gt;
					&lt;th&gt;380v三相&lt;/th&gt;
					&lt;th&gt;240v 直流&lt;/th&gt;
			&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
			&lt;tr&gt;
					&lt;td&gt;电压危险性&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;每1kw功率电流&lt;/td&gt;
					&lt;td&gt;2.63A&lt;/td&gt;
					&lt;td&gt;4.55A&lt;/td&gt;
					&lt;td&gt;1.52A&lt;/td&gt;
					&lt;td&gt;4.17A&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;线材成本系数&lt;/td&gt;
					&lt;td&gt;2.63 * 3+1&lt;/td&gt;
					&lt;td&gt;4.55 * 2+1&lt;/td&gt;
					&lt;td&gt;1.52 * 4+1&lt;/td&gt;
					&lt;td&gt;4.17 * 2&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;电能质量&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;低 （100hz功率波动）&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;异步电机转矩&lt;/td&gt;
					&lt;td&gt;恒转矩&lt;/td&gt;
					&lt;td&gt;100hz 转矩波动&lt;/td&gt;
					&lt;td&gt;恒转矩&lt;/td&gt;
					&lt;td&gt;无法使用&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;故障保护成本&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;中&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;三相失横危险性&lt;/td&gt;
					&lt;td&gt;低&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;高&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;三相失横表现&lt;/td&gt;
					&lt;td&gt;欠压 （罢工）&lt;/td&gt;
					&lt;td&gt;过压 （烧毁） 或 欠压（罢工）&lt;/td&gt;
					&lt;td&gt;过压（烧毁） + 失压&lt;/td&gt;
					&lt;td&gt;无&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;380v 三相异步电机兼容性&lt;/td&gt;
					&lt;td&gt;星接改三角&lt;/td&gt;
					&lt;td&gt;无法使用&lt;/td&gt;
					&lt;td&gt;直接使用&lt;/td&gt;
					&lt;td&gt;无法使用&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;220v 三相异步电机兼容性&lt;/td&gt;
					&lt;td&gt;直接使用&lt;/td&gt;
					&lt;td&gt;无法使用&lt;/td&gt;
					&lt;td&gt;三角改星接&lt;/td&gt;
					&lt;td&gt;无法使用&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;220v 单相电机兼容性&lt;/td&gt;
					&lt;td&gt;接任意2火线 （三相不平衡）&lt;/td&gt;
					&lt;td&gt;直接使用&lt;/td&gt;
					&lt;td&gt;接任一火线 （三相不平衡）&lt;/td&gt;
					&lt;td&gt;无法使用&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;开关电源兼容性&lt;/td&gt;
					&lt;td&gt;接任意2火线 （三相不平衡） /  整流后输入 （三相平衡）&lt;/td&gt;
					&lt;td&gt;直接使用&lt;/td&gt;
					&lt;td&gt;接任一火线（三相不平衡）&lt;/td&gt;
					&lt;td&gt;直接使用&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;全桥整流后电压&lt;/td&gt;
					&lt;td&gt;310v&lt;/td&gt;
					&lt;td&gt;310v&lt;/td&gt;
					&lt;td&gt;540v&lt;/td&gt;
					&lt;td&gt;240v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;电子器件耐压等级&lt;/td&gt;
					&lt;td&gt;650v&lt;/td&gt;
					&lt;td&gt;650v&lt;/td&gt;
					&lt;td&gt;1200v&lt;/td&gt;
					&lt;td&gt;450v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;输入整流成本&lt;/td&gt;
					&lt;td&gt;650v耐压二极管*6 + 小电容&lt;/td&gt;
					&lt;td&gt;650v耐压二极管*4 + 大电容 + NTC&lt;/td&gt;
					&lt;td&gt;1200v耐压二极管*6 + 小电容&lt;/td&gt;
					&lt;td&gt;小电容&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;逆变方式&lt;/td&gt;
					&lt;td&gt;310v 直流母线  + 6管全桥逆变&lt;/td&gt;
					&lt;td&gt;310v 直流母线+4管全桥逆&lt;/td&gt;
					&lt;td&gt;540v直流母线  + 6管全桥逆变&lt;/td&gt;
					&lt;td&gt;&lt;/td&gt;
			&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;在三种供电制度下，各自有最适合的电机，而相同功率下的不同电机的成本对比：&lt;/p&gt;</description>
    </item>
    <item>
      <title>LLC 的调频控制</title>
      <link>https://microcai.org/2025/02/06/LLC-explained.html</link>
      <pubDate>Thu, 06 Feb 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/02/06/LLC-explained.html</guid>
      <description>&lt;h1 id=&#34;llc-调压的的物理原理&#34;&gt;LLC 调压的的物理原理&lt;/h1&gt;
&lt;p&gt;LLC 之所以叫 LLC ， 是因为电路等效为 两个 L 和一个 C。但那是分析用的，实际上电路就一个 L 和一个 C。 当然故意接2个 L 也可以的。只不过会增加成本。&lt;/p&gt;
&lt;p&gt;LLC 谐振的原理呢，其实就是LC振荡器。但是不是自激振荡，而是他激。根据激发他的外部输入电路的不同，分为全桥LLC和半桥LLC。&lt;/p&gt;
&lt;p&gt;LLC 为何通过调节频率，能调节输出电压呢？&lt;/p&gt;
&lt;p&gt;看电路：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/llc.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;LLC 尽管实际电路上就一个 变压器和一个电容，但是因为变压器有漏感，所以 LLC 可以看成是 一个 LC 滤波器接上一个变压器。&lt;/p&gt;
&lt;p&gt;是的，没错，就是一个 LC 滤波器。&lt;/p&gt;
&lt;p&gt;这个 LC 滤波器呢，就有一个谐振频率，高于它的和低于它的频率，能量都会被削弱。&lt;/p&gt;
&lt;p&gt;因此，当外部输入的频率，高于或者低于谐振频率的时候，等于这个 LC 滤波器对输入的交流电进行了滤波。也就是被衰减。那么衰减后施加在变压器上的电压就不再是原始电压了。
于是次级绕组输出电压就降低。&lt;/p&gt;
&lt;p&gt;只有工作在谐振频率的时候，滤波器增益为 1, 也就是能量完全通过滤波器。于是次级绕组输出电压最大。&lt;/p&gt;
&lt;p&gt;但是，我要说但是了。为啥 LLC 一定要有漏感呢？ 而且漏感还不能小。其实主要原因是：这个滤波器的谐振频率是会随着负载变化的。
漏感越大，则谐振频率随负载变化越小。&lt;/p&gt;
&lt;p&gt;为啥谐振频率会变化呢？ 这就要说到变压器的特点了。变压器的初级绕组能量完全传递给次级，那么铁芯就不会有磁链。也就是说，这个线圈不会产生电感。
如果次级没有能量消耗，那么电流的能量就会转换成磁链储存在铁芯里。也就是说，这个线圈会有个最大的电感。&lt;/p&gt;
&lt;p&gt;因为现实变压器不是理想变压器，因此，初级的能量无法完全传递给次级。所以这个无法完全传递过去的能量就会驻留在铁芯里，形成 “漏感”。在传统的反激或者正激变换器里，漏感是个坏东西。要尽量消除。
而在 LLC 架构里，这个漏感反而是必须的。因为如果没有漏感，则次级完全消纳初级能量后，LC谐振电路因为没有电感就被破坏掉了。
在 LLC 架构里，漏感不仅仅需要，而且还得很大。因为变压器哦绕组的电感，会随着次级消耗的能量多寡而变动，因此，这个 LC 滤波器，电路中串入的 L 的数值就会变动。这导致滤波器的谐振频率会有一个很大的变动。为了降低谐振频率的变动范围，就需要变压器有较大的漏感。或者，外部再串入一个电感。&lt;/p&gt;
&lt;h1 id=&#34;调频不是为了调压&#34;&gt;调频不是为了调压&lt;/h1&gt;
&lt;p&gt;很多对 LLC 的理解不深刻的人，很容易把 LLC 看成是一种通过调节 pwm 频率来调节输出电压的拓扑结构。其实这种做法是严重错误的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>动能回收的实现方式</title>
      <link>https://microcai.org/2025/01/27/regenerative-explained.html</link>
      <pubDate>Mon, 27 Jan 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/01/27/regenerative-explained.html</guid>
      <description>&lt;p&gt;电动汽车进行动能回收的原理就是电动机可以作为发电机使用。&lt;/p&gt;
&lt;p&gt;但是具体是怎么实习的呢？&lt;/p&gt;
&lt;h1 id=&#34;方法1当发电机使用&#34;&gt;方法1，当发电机使用&lt;/h1&gt;
&lt;p&gt;发电机发的电，如何转换成直流电？ 答案是 整流，然后经过 Boost 升压。为何要升压呢？因为感应电动势小于电池电压。&lt;/p&gt;
&lt;p&gt;也就是说动能回收的时候，电机输出电压要小于电池电压。因此整流后，还要经过一个升压，然后就能冲入电池了。&lt;/p&gt;
&lt;p&gt;调节升压电路的输出电压，就可以调节充电电流，也就是调节了动能回收的功率。&lt;/p&gt;
&lt;p&gt;因此动能回收可以是一条独立的电路。其电路就是 6个二极管构成的三相整流桥 + 1或2个 mos管构成的非同步或同步Boost升压电路。&lt;/p&gt;
&lt;h1 id=&#34;方法2使用4象限逆变器&#34;&gt;方法2，使用4象限逆变器&lt;/h1&gt;
&lt;p&gt;前一个方法要增加一套电路，成本大大的。其实完全可以复用逆变器的电路。&lt;/p&gt;
&lt;p&gt;那么具体的来说，就是让逆变器输出的三相电压的相位，完全跟随电动机旋转时产生的3个反电动势电压的相位。但是，逆变器输出的电压，略低于电动机的反电动势。&lt;/p&gt;
&lt;p&gt;于是，电流就会逆向流动。从电动机反向流入逆变器的直流母线。
导致直流母线电压抬升。&lt;/p&gt;
&lt;p&gt;而逆变器的直流母线又是和电池并联的，于是电流逆向流入电池。完成充电。&lt;/p&gt;
&lt;p&gt;而控制逆变器的输出电压和电机反电动势的电压差，就可以控制充电电流的大小。&lt;/p&gt;
&lt;p&gt;进而控制动能回收功率。&lt;/p&gt;
&lt;p&gt;其实做过三相功率因素矫正电路的人都知道，其电路也是6个MOS管。实际上三相带功率因素矫正的整流电路，本质上就是个工作在动能回收模式的逆变器。只是和电机的逆变器直接使用角度传感器获得转子位置（进而获得各相电压相位）不同，功率因素矫正电路使用锁相环电路获得市电的相位。&lt;/p&gt;
&lt;p&gt;而且，使用此方法，也不需要对电控的代码进行修改。&lt;/p&gt;
&lt;p&gt;哈哈，这是为啥呢？&lt;/p&gt;
&lt;p&gt;因为现有的电控代码，都是使用 DQ 坐标系进行控制的。在控制代码里，其实只要简单的将 闭环控制目标设定为输出负 Q轴电流，剩下的代码，自动的就会将逆变器的工作模式切换为上述流程。
不需要额外增加代码。&lt;/p&gt;
&lt;p&gt;既然正向输出的 “功率限制” 功能都是现成的，那么动能回收控制功率就是换个正负号的事情。&lt;/p&gt;</description>
    </item>
    <item>
      <title>电机控制的几个思索</title>
      <link>https://microcai.org/2025/01/26/motor-and-regenerative.html</link>
      <pubDate>Sun, 26 Jan 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/01/26/motor-and-regenerative.html</guid>
      <description>&lt;h1 id=&#34;关于能量转化上的思考&#34;&gt;关于能量转化上的思考&lt;/h1&gt;
&lt;p&gt;电动机，供电即转。转即发电。&lt;/p&gt;
&lt;p&gt;无负载的情况下，电机无功率输出，（理论上）无功率消耗。&lt;/p&gt;
&lt;p&gt;通电即转，和无功率消耗的矛盾是如何化解的呢？那就是“反电动势”。
在无负载的情况下，电机的转速会达到反电动势等于输入电压。&lt;/p&gt;
&lt;p&gt;此时输入电压完全和反电动势抵消。于是绕组实际上无电流通过。因此不产生扭矩。故 电压*0电流 = 0 功率。&lt;/p&gt;
&lt;p&gt;只要有负载，转速就会低于空载转速，于是反电动势低于输入电压。绕组产生电流，建立磁场，电机产生扭矩输出。&lt;/p&gt;
&lt;p&gt;因此电机消耗的电流，大致相当于 （输入电压 - 反电动势）/绕组阻抗。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;注：绕组阻抗是由电阻和电抗叠加而来的。因此超导做的绕组依然不会有无穷大电流。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h1 id=&#34;关于空挡滑行再启动&#34;&gt;关于空挡滑行再启动&lt;/h1&gt;
&lt;p&gt;在控制策略上，空挡滑行有2种控制策略&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;切断供电回路&lt;/p&gt;
&lt;p&gt;控制器停止工作并切断回路（6个MOS管全部关闭）。切断电路后，电机空挡旋转产生的反电动势没有回路。因此不产生电流。电机进入空挡滑行状态。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;控制器输出电压跟随反电动势，确保绕组无电流&lt;/p&gt;
&lt;p&gt;此模式下，控制器继续积极工作。但是始终保证控制器输出的电压等于电机反电动势。确保相电流为0。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;第二种模式下，电机空挡滑行的时候，控制器仍然在积极工作，因此存在不大不小的损耗。&lt;/p&gt;
&lt;p&gt;从节能减排的角度而言，应该优先选择第一种策略。&lt;/p&gt;
&lt;p&gt;那么第二种策略是为何产生的呢？&lt;/p&gt;
&lt;p&gt;答案就是在空挡滑行状态再加速（松油门滑行后，再踩油门加速）的情况下。二者会产生不同的响应特点。&lt;/p&gt;
&lt;h3 id=&#34;切断回路模式的再加速工作特点&#34;&gt;切断回路模式的再加速工作特点&lt;/h3&gt;
&lt;p&gt;由于控制器停止工作，因此控制器输出电压为 0。
因此，再加速的时候，控制器输出电压就需要“重新建立”。控制器的输出电压会经历一次从 0 到超过反电动势电压的一个“攀升”的过程。值得一提的是，在控制器输出0电压的时候，因为6管全关，因此起到了切断电路的效果，因此只有控制器 开始工作，电压输出开始不为0的时候，电路才接通。&lt;/p&gt;
&lt;p&gt;这个过程虽然很短暂（一般而言是几十个毫秒），但是在攀升的过程中，存在短暂的控制器输出电压低于电机反电动势的时间。这个时间电机就会输出负扭矩。如果这个负扭矩较大，就会在体感上形成一个类似燃油车挂档不合适导致的“顿挫” —— 松离合器的时候，发动机被车速强行带上更高转速，从而导致一段时间内发动机输出负扭矩。&lt;/p&gt;
&lt;p&gt;故为了消除这个顿挫，才有了控制器持续工作的空挡滑行模式。&lt;/p&gt;
&lt;h3 id=&#34;相电流闭环控制为0的再加速特点&#34;&gt;相电流闭环控制为0的再加速特点&lt;/h3&gt;
&lt;p&gt;由于使用了闭环控制。因此空挡后再加速的时候，只要将闭环控制的电流目标调节为 &amp;gt; 0 即可立即输出扭矩。
不会经历一个短暂的 “顿挫” 过程。&lt;/p&gt;
&lt;h1 id=&#34;强制动能回收&#34;&gt;强制动能回收&lt;/h1&gt;
&lt;p&gt;但是，在空挡滑行的时候，还让控制器持续工作，意味着不能实现6个 mos管全关的节能模式。&lt;/p&gt;
&lt;p&gt;舒适了，但是并不节能。&lt;/p&gt;
&lt;p&gt;如果强制动能回收。则可以强迫驾驶员用自己的脚避免进入 “松油门滑行” 状态。等于完全取消了这个工况。&lt;/p&gt;
&lt;p&gt;因此即避免了关控制器模式的顿挫，也避免了闭环0电流滑行的损耗。&lt;/p&gt;
&lt;p&gt;与此同时，还不需要设计 机械刹车和动能回收的协调工作。&lt;/p&gt;
&lt;p&gt;三赢。&lt;/p&gt;</description>
    </item>
    <item>
      <title>福特和福建的弹射技术对比</title>
      <link>https://microcai.org/2025/01/15/ac-electromagnetic-launch.html</link>
      <pubDate>Wed, 15 Jan 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/01/15/ac-electromagnetic-launch.html</guid>
      <description>&lt;p&gt;电磁弹射，被加速的舰载机总重，30吨，即3万公斤；加速长度100米，加速时间2.2秒，舰载机末端速度，85米每秒；总耗电能38度；瞬间功率6万千瓦。&lt;/p&gt;
&lt;p&gt;福特航母在上实际90年代立项。 上世纪90年代，哪家公司能拿出功率达到 6万千瓦的变频器和储能40度电的超级电容呢？&lt;/p&gt;
&lt;p&gt;这就是有时候，先驱变成先烈的问题。&lt;/p&gt;
&lt;p&gt;因为当年没有大功率的逆变器技术，
因为超大功率的逆变器是随着特高压直流输电才研发出来的。
所以福特就只能上不需要逆变器的异步电机。由发电机直接供电。&lt;/p&gt;
&lt;p&gt;发电机直接供电，瞬间大负载下，发电机的转速（也就是发电频率）就会掉。而没有任何原动机能实现这么快速的调频。
防止掉频率的方法就是加大质量的飞轮。作用就和拖拉机上的那个大飞轮一样。&lt;/p&gt;
&lt;p&gt;依靠飞轮的巨大惯性，防止发电机转子转速下降。&lt;/p&gt;
&lt;p&gt;而且动能回收也非常简单，异步电机只要转速超过同步转速就自动进入发电状态。
因此只要给回收缆绳上接一个电机，飞机降落的时候以极高的速度拉扯缆绳。缆绳带动电机发电，这个电直接并入航母电网。由于缆绳带动的是异步电机，
因此不需要同步就可以并网。电能输入航母电网。然后整个航母电网电压提升，带着飞轮的发电机由于电网不再从发电机汲取能源，导致发电机变为电动机，从电网提取能量。
从而实现储能。&lt;/p&gt;
&lt;p&gt;所以，这个交流技术其实是很成熟很稳定的。&lt;/p&gt;
&lt;p&gt;由于整个系统的交流频率和飞轮转速挂钩。因此是运行在在某个区间内“变动”的频率上的。和陆地上固定频率的电网不同。
但是频率的范围也不能太大。猜测系统频率在 350hz ~ 450hz 之间。
这样有效的频率范围就只有 100hz 。 也就是说， 0-350hz 这个区间对应的飞轮转速是 “无用转速”。&lt;/p&gt;
&lt;p&gt;因此飞轮质量必须非常大，转速必须非常高。这样才能在狭窄的可用转速区间内，输出足够的储能。&lt;/p&gt;
&lt;p&gt;由于4条弹射器不可能同时运作。其1是放飞跑道有交叠，其二是为了飞机起飞后的涡流干扰考虑。&lt;/p&gt;
&lt;p&gt;因此，基于控制成本的考虑，福特使用的是 4台发电机+4个飞轮+4个弹射器 这样的组合。但是每台发电机只有1万千瓦功率。这样可以大幅降低总成本和总质量。
这样，运作的时候，实际上就是4台发电机并联发电，但是每次只给一台弹射器供电。&lt;/p&gt;
&lt;p&gt;为了避免4台发电机之间复杂的相位同步并网问题，福特使用的每条弹射器，是4条直线电机并联输出动力的。
这意味着，4台发电机少一台，弹射器就无法工作。&lt;/p&gt;
&lt;p&gt;下面是我画的示意图：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/fute_tansheqi.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;从结构图里可以很清晰的推断出来，福特航母弹射器坏一条就4条不能用。&lt;/p&gt;
&lt;p&gt;但是，只要每个零件的可靠性做的很高，那么整个系统的可靠性也不是说不能用。&lt;/p&gt;
&lt;p&gt;因此，福特的技术路线，并不是错误的，不可取的。
而是着眼于当年的技术水平限制做的设计。&lt;/p&gt;
&lt;p&gt;而一旦掌握了特高压直流输电，就一定会掌握一个重要技术：超大功率直流/交流逆变器。&lt;/p&gt;
&lt;p&gt;这个逆变器是弹射器能使用“直流供电”的前置技术。&lt;/p&gt;
&lt;p&gt;而一旦有了这个逆变器，则整个设计可以“直流化”。&lt;/p&gt;
&lt;p&gt;整个系统架构如下图:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/fujian_tansheqi.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;注意这个储能电池和电网之间，实际上并不需要任何“控制器”。而是直接并联。&lt;/p&gt;
&lt;p&gt;比如这个电池使用 3700v 电池组。（一千节锂电池串联）。&lt;/p&gt;
&lt;p&gt;那么只要是输出 4200v 电压的发电机，都可以并到这个直流电网里。&lt;/p&gt;
&lt;p&gt;只要用电侧使用功率低于发电功率，电池就会自动“吸纳”多余电流。
而只要用电侧使用功率高于发电功率，电池就会自动放电维持电网电压。&lt;/p&gt;
&lt;p&gt;这个是电池的工作性质决定的。&lt;/p&gt;
&lt;p&gt;实际上每台汽车，都有这么一个直流电网。这个电网就是靠12v蓄电池进行稳压储能的。
12v蓄电池满电电压是 14.4v，因此汽车发电机输出一个14.4v电压。并且和电池直接并联。&lt;/p&gt;
&lt;p&gt;电池未充满的情况下，发电机输出电压被电池拉低。发电机输出最大功率。电池充电功率 = 发电机功率-用电功率。 发电机工作在恒流模式。电池充满达到14.4v 后。发电机在内部稳压系统的作用下，会减小励磁电流，进而减少发电功率。发电机工作在恒压模式。如果有个瞬时的大功率用电设备开启，则整个系统电压就会偏离 14.4v 。 电池自动进入放电模式来弥补发电机的功率缺口。&lt;/p&gt;
&lt;p&gt;这就是直流电网的巨大“储能优势”。并不需要复杂的控制器，仅仅是将电池并联到电网上就可以全自动实现储能和放能。&lt;/p&gt;</description>
    </item>
    <item>
      <title>资本主义绝户计</title>
      <link>https://microcai.org/2025/01/08/capitalism-and-self-emasculation.html</link>
      <pubDate>Wed, 08 Jan 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/01/08/capitalism-and-self-emasculation.html</guid>
      <description>&lt;p&gt;全世界的文明，都陷入了一个困境：经济越是发达，生育率越低。&lt;/p&gt;
&lt;p&gt;很多人说，这是因为经济发达了，妇女受教育程度高了。女性不愿意生孩子了。&lt;/p&gt;
&lt;p&gt;这就是典型的胡说八道。但是这种错误认知居然还是当下的主流认知。&lt;/p&gt;
&lt;p&gt;为什么说这个认知是错误的呢？女性接受教育就会自我阉割放弃生育权？
这个错误的离谱之处在于，否认了男性在抚养后代上的承担。仿佛孩子只要生下来就可以自动长大。&lt;/p&gt;
&lt;p&gt;生孩子只要幸苦10个月，养孩子则要幸苦一辈子。
只要这个社会进步到了，孩子不能管生不管养，生育率就会断崖式下跌。和女性是否接受教育没有关系。&lt;/p&gt;
&lt;p&gt;让生育率下跌的，从来不是所谓的女权觉醒，而是养育孩子的成本越来越高。高到6个钱包都无力供养的情况下，自然整个社会就开始自我绝育了。&lt;/p&gt;
&lt;p&gt;在进行进一步论述前，首先要在基本观念上取得共识：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;人，首先要养活自己，然后才谈的上养育后代。&lt;/li&gt;
&lt;li&gt;人，都希望自己的下一代活的比自己好。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;一个族群人口是否扩张，取决于这2个先决条件。&lt;/p&gt;
&lt;p&gt;一个人人都无法养活自己的族群，必然人口萎缩。就算孩子出生率很高，也必然面临大量的夭折儿童。
一个人人只能缩衣节食，然后一代过的不如一代的族群，必然也是人口萎缩的。就算勉强为了所谓的传宗接代而维持出生率。面对一代过的不如一代的事实，也会让人心生绝望。直到某一代，连养活自己都无法维持。&lt;/p&gt;
&lt;p&gt;好了，有了以上的共识，为啥说资本主义是绝户计呢？&lt;/p&gt;
&lt;h1 id=&#34;造不如买买不如租&#34;&gt;造不如买，买不如租&lt;/h1&gt;
&lt;p&gt;我们知道，造不如买，买不如租。比如过去大户人家，他们虽然会有很多“家生子”，但是府中奴仆的主力来源依然是 “买”。（所谓“家生子”是指家中奴仆生育的后代，由主人完全出资养大。）根本原因就是因为养大一个家生子的开销，远大于从外部购买一个已经成年的劳动力。&lt;/p&gt;
&lt;p&gt;而买不如租，就是资本主义的逻辑。买来的奴仆，主人还是要负责他的生老病死。
而租来的奴仆，主人完全享受他“健康壮年期”的劳动，而不需要承担其他任何开销。&lt;/p&gt;
&lt;p&gt;20岁-60岁，资本家只需要花费 400万 就可以买断一个人一辈子的劳动。
这 400万，资本家获得的是一个 “上过大学”，接受过优质教育的奴仆。而且400万是上限。期间奴仆如果生病了，不能履行职责了，都可以换一个。换一个人是没有额外成本的。甚至还可以要求租来的奴仆在无法履职的期间反向赔偿主人的损失。&lt;/p&gt;
&lt;p&gt;如果资本家不使用“租”的方式。他要支付多少钱呢？ 首先，从0岁养到大学毕业，资本家要支出大约200万。
而且，还有一定的“废品率”。也就是说有一部分买来的奴仆，将永久性无法承担高级工作。&lt;/p&gt;
&lt;p&gt;其次，20岁到60岁，资本家虽然不需要支付工资，但是期间的衣食住行一样要大约支付200-300万。
最后，60岁开始，奴仆无力劳动，但是还是要养他到老。期间的衣食住行差不多还得 100万。&lt;/p&gt;
&lt;p&gt;看到没？使用“雇佣制”下，资本家节约了大量的“养育”成本。同时不承担“废品率”。资本家唯一多支出的期间，是壮年期，给奴仆发放的工资，要高于“养一个奴仆”的衣食住行开支。&lt;/p&gt;
&lt;p&gt;而这部分多列的开支，已经用“不承担养育和养老成本”给节约回来了。而且还免去了“养废“的风险。&lt;/p&gt;
&lt;p&gt;而且还有一个重大优势：不需要等待二十几年才能获得一个高级奴仆。而是可以立即获得。&lt;/p&gt;
&lt;p&gt;与此同时，租来的壮年期的奴仆工作效率也远远高于买来的奴仆。哪怕不考虑节约的养育和养老开销，租相比买都是赚了的。&lt;/p&gt;
&lt;p&gt;好了，这是雇佣制替代奴隶制背后的经济逻辑。&lt;/p&gt;
&lt;p&gt;那么这个经济逻辑为何会影响生育率呢？&lt;/p&gt;
&lt;h1 id=&#34;劳动力再生产&#34;&gt;劳动力再生产&lt;/h1&gt;
&lt;p&gt;在资本主义下，人是被 “物化”的。因此我这里也使用物化的逻辑看待人口。
劳动力，其实也是一种”生产资料&amp;quot;。由氨基酸构成，葡萄糖驱动的机器，和钢铁构成，烃烷驱动的机器，在资本家的眼里是没有区别的。都是生产线的组成部分。&lt;/p&gt;
&lt;p&gt;一条生产线，任何一个零件老化，都需要生产一个新的零件换上。&lt;/p&gt;
&lt;p&gt;对资本家来说，这叫“产线更新”。&lt;/p&gt;
&lt;p&gt;资本家需要将商品利润的一部分，投入“生产线的更新”。&lt;/p&gt;
&lt;p&gt;但是很不巧的是，在资本主义制度下，氨基酸构成的机器，其“生产线的更新”成本是由机器自己承担的。
也就是说，资本家将人力资源的使用方式，等同于“石油天然气”一样的“不可再生矿产”。
采取的做法是用完就废弃。然后去别的地方挖新的。&lt;/p&gt;
&lt;p&gt;因此，资本主义才会不断的谋求“产业链转移”。将钢铁构成的生产线不断的移动到有新鲜的氨基酸零件的地方。
一旦将这个地方的氨基酸机器挥霍的差不多了，就转移到另一个地方。&lt;/p&gt;
&lt;p&gt;资本家并不谋求这些氨基酸构成的产线零件的 “可持续更新”。&lt;/p&gt;
&lt;p&gt;至于这些零件如果还有祖传的责任，于是以极大的压缩自身需求为代价，努力的为资本家培养下一代耗材，则资本家不过是减缓了产业链转移的速度。&lt;/p&gt;
&lt;p&gt;因为，这样做，必然导致 ”活的越来越差“。而这是反人性的。&lt;/p&gt;
&lt;h1 id=&#34;生育率&#34;&gt;生育率&lt;/h1&gt;
&lt;p&gt;所以生育率的降低的根本原因已经呼之欲出了。就是资本主义下，对人力资源是涸泽而渔的。&lt;/p&gt;
&lt;p&gt;除非人力资源自己能放弃自己身为人的尊严，只为“产子”这一个目的而活。&lt;/p&gt;
&lt;p&gt;而耗材一旦不放弃人的尊严，就被扣上了 “知识越多越不生” 的帽子。&lt;/p&gt;
&lt;p&gt;然后用所谓的“生育率下降是经济发展的必然结果”来忽悠&lt;/p&gt;</description>
    </item>
    <item>
      <title>调用约定和上下文切换</title>
      <link>https://microcai.org/2025/01/03/calling-convertion-and-context-swap.html</link>
      <pubDate>Fri, 03 Jan 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/01/03/calling-convertion-and-context-swap.html</guid>
      <description>&lt;p&gt;编写协程库的时候，我常常在想，上下文切换的速度，受&lt;strong&gt;调用约定&lt;/strong&gt;的影响非常大。&lt;/p&gt;
&lt;p&gt;因为用户协程的上下文切换，本质上是调用一个 函数。而这个函数需要 “切换” 非易失性寄存器。&lt;/p&gt;
&lt;p&gt;因此，在给定的调用约定下，非易失性寄存器越多，则上下文切换时需要保留和恢复的寄存器数量就越多。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;而由内核进行上下文切换(也就是线程)，所有寄存器都得保留。开销是最大的。何况还有执行特权级切换的巨大开销。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;在知乎上发表的批评 云风的 coroutine 库的文章的评论区里，有个人提到了 &lt;a href=&#34;https://photonlibos.github.io/blog/stackful-coroutine-made-fast&#34;&gt;这篇文章&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;好家伙，他们对内联汇编玩出花来了。使用内联汇编的 clobbered registers 列表来自动生成寄存器的保存和恢复代码。&lt;/p&gt;
&lt;p&gt;然后，他们给 clang 提了一个补丁，增加了一个叫 &lt;code&gt;preserve_none&lt;/code&gt; 的调用约定。&lt;/p&gt;
&lt;p&gt;所谓 &lt;code&gt;preserve_none&lt;/code&gt;，顾名思义，就是这个调用约定下，尽可能啥寄存器都不保留，全是易失性寄存器。&lt;/p&gt;
&lt;p&gt;于是，如果使用 &lt;code&gt;preserve_none&lt;/code&gt; 的调用约定实现 &lt;code&gt;zcontext_swap&lt;/code&gt;, 则代码里并不需要保留上下文。只需要切换 rsp 寄存器，然后调用下 hook 即可返回了。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-asm&#34; data-lang=&#34;asm&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;zcontext_swap_preserve_none:
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 保存frame寄存器
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;push&lt;/span&gt; %rbp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 切换栈指针
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %rsp, (%r12)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; (%r13), %rsp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;//  恢复 frame 寄存器
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;pop&lt;/span&gt; %rbp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// if(hook_function) hook_function(argument);
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;test&lt;/span&gt; %r14, %r14
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;jne&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;f&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 返回 argument
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, %rax
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 返回
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;ret&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;1:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 如果有 hook ，则调用 hook 后返回
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, &lt;span style=&#34;color:#66d9ef&#34;&gt;ARG1_REG&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, %r12 &lt;span style=&#34;color:#75715e&#34;&gt;// 同时兼容 preserve_none 调用约定 的 hook
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;jmp&lt;/span&gt; * %r14 &lt;span style=&#34;color:#75715e&#34;&gt;// 开启尾调用优化.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在 无 hook 的情况下，只需 8 条指令即完成上下文切换。&lt;/p&gt;</description>
    </item>
    <item>
      <title>在Linux上交叉编译windows版 Qt 和 qt应用</title>
      <link>https://microcai.org/2024/12/31/cross-compile-qt-app-by-clang.html</link>
      <pubDate>Tue, 31 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/31/cross-compile-qt-app-by-clang.html</guid>
      <description>&lt;h1 id=&#34;准备工具链&#34;&gt;准备工具链&lt;/h1&gt;
&lt;p&gt;一个半月前，我研究了一下 &lt;a href=&#34;https://microcai.org/2024/11/16/cross-compile-by-clang.html&#34;&gt;使用本机 clang 进行交叉编译&lt;/a&gt;。那时候，是在本机 x86 上交叉编译 arm 和 mips 架构的软件。目标系统还是 linux 的。&lt;/p&gt;
&lt;p&gt;交叉编译，需要使用交叉工具链。而使用本机clang进行交叉编译，只是将交叉工具链里的“编译器”换成了本机本就安装的 clang, 而 “头文件和库文件” 则是使用 archlinux 和 mips debian 的 rootfs 提供。
缺啥库，qemu-user + chroot 进去后直接安装即可。&lt;/p&gt;
&lt;p&gt;关于如何进行异构chroot, 我在 &lt;a href=&#34;https://microcai.org/2011/04/26/chrootarm.html&#34;&gt;chroot to arm on an x86 Gentoo
&lt;/a&gt; 和 &lt;a href=&#34;https://microcai.org/2022/04/26/hybrid-container.html&#34;&gt;异构容器&lt;/a&gt; 里分别讲述过。&lt;/p&gt;
&lt;p&gt;但是，一个合格的开发者，怎么可能只写 Linux 程序呢？&lt;/p&gt;
&lt;p&gt;非常自然的，交叉编译到 windows 上也是一个正经需求。&lt;/p&gt;
&lt;p&gt;要交叉到 windows 上，通常的做法是使用 MinGW。MinGW 不仅仅是一套移植到 Windows 上的 gcc 工具链，还是一套在 Linux 下产生exe文件的交叉编译器。&lt;/p&gt;
&lt;p&gt;但是正如标签里的 clang 所言，本篇介绍的，可不是 MinGW ， 而是继续使用本机的 clang 进行交叉编译 exe。&lt;/p&gt;
&lt;p&gt;编译器本机早就有了，头文件和库呢？&lt;/p&gt;
&lt;p&gt;答案是，还得从 mingw 里拿。&lt;/p&gt;
&lt;p&gt;通常来说， mingw 里是一套 “自由” 的 sdk. 意味着它使用 动态链接的 MSVCRT.DLL 作为 C 库, 然后辅之以  libmingw32-1.dll 作为 posix 兼容层，然后 libgcc-1.dll 作为 编译器运行时。
然后是 libwinpthread-1.dll 提供 pthread ，然后使用 libstdc++-1.dll 提供 c++ 标准库。&lt;/p&gt;</description>
    </item>
    <item>
      <title>协程切换为什么需要 一个 hook_function 参数.</title>
      <link>https://microcai.org/2024/12/28/context-switch-need-a-hook.html</link>
      <pubDate>Sat, 28 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/28/context-switch-need-a-hook.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;刚刚，我将 zcontext 的 API 进行了以下修正。&lt;/p&gt;
&lt;p&gt;从&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;zcontext_swap&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; from, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; to, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; argument);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;改成了&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_swap_hook_function_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;zcontext_swap&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; from, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; to, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_swap_hook_function_t&lt;/span&gt; hook_function, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; argument);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;增加了一个 hook_function。这是为何呢？这个 hook_function 又是怎么使用的呢？在什么情况下运行呢？&lt;/p&gt;
&lt;p&gt;别着急，我一一道来。&lt;/p&gt;
&lt;h2 id=&#34;需求1自动进行栈回收&#34;&gt;需求1：自动进行栈回收&lt;/h2&gt;
&lt;p&gt;协程需要分配一个新栈。而协程执行完毕的时候，需要对分配的栈内存进行回收。
而协程自身是无法执行这个任务的。协程只有不在运行状态，他的栈才能释放。而他在运行状态下，又如何调用 free 释放自己呢？
free 本身运行也依赖栈。free 不能把自己正在使用的栈给释放了。&lt;/p&gt;
&lt;p&gt;因此，这个需求我用了一些比较绕的方法实现了。其实就是让调度器负责回收。这就限制了调度器只能跑在主线程上。
并且调度器（主事件循环）需要和协程的代码进行一定程度的耦合。&lt;/p&gt;
&lt;p&gt;但是为了解决内存泄漏，这个耦合也是不得不为之。其实应该有更好的解决方法的。&lt;/p&gt;
&lt;h2 id=&#34;需求2线程安全的协程切换&#34;&gt;需求2：线程安全的协程切换&lt;/h2&gt;
&lt;p&gt;在多线程运行调度器的情况下，可能发生协程切换的竞争。具体情况如下：&lt;/p&gt;
&lt;p&gt;假设运行2个线程执行 GetQueuedCompletionStatus。姑且称为 主线程A, 主线程B.
为了更好的性能，通常的做法是让线程A负责 accept, 而线程B负责处理客户端连接。如果处理客户端有瓶颈，还可以创建更多的线程处理。
这里先简化为2个线程。&lt;/p&gt;
&lt;p&gt;系统运行若干个 Accept 协程。并且在接受一个新连接后，创建一个新的处理协程来处理新的连接。
姑且称是协程A吧。某个协程 A 拿到了一个新连接后，创建一个新的处理协程来处理新的连接。
姑且称这个刚刚创建的新协程为 协程C，这个新接受的连接对应 socket C。&lt;/p&gt;
&lt;p&gt;好了，协程A, 接受了一个新连接，然后创建了 协程 C。此时协程 C 和协程 A ，都是在主线程 A 上运行的。&lt;/p&gt;
&lt;p&gt;这时，我们要往socket C 上投递 WSARecv 了。此时投递是在 主线程A上进行的。由于 socket C 绑定了线程B的 IO完成端口，因此稍后
会在主线程 B 上获得完成事件。此时协程 C 是在 线程 A 上运行的。调用 WSARecv 后，紧接着就要进行“协程挂起”操作。
正常来说，线程B获得socket C 的完成事件后，就会恢复协程C。于是，协程 C 后续就在 线程 B 上运行了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>从0开始写上下文切换</title>
      <link>https://microcai.org/2024/12/26/context-switch-explained.html</link>
      <pubDate>Thu, 26 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/26/context-switch-explained.html</guid>
      <description>&lt;h1 id=&#34;有栈协程的核心是执行上下文执行上下文的核心是栈&#34;&gt;有栈协程的核心是执行上下文。执行上下文的核心是栈。&lt;/h1&gt;
&lt;p&gt;因此，切换栈就等于切换了上下文。&lt;/p&gt;
&lt;h1 id=&#34;栈在协程切换上的核心地位&#34;&gt;栈在协程切换上的核心地位&lt;/h1&gt;
&lt;p&gt;栈，存储了一个协程/线程 的“调用链”，以及依附于这条链上的“变量”。&lt;/p&gt;
&lt;p&gt;没有栈，ret 指令将无所适从。&lt;/p&gt;
&lt;p&gt;虽说栈是核心，但是栈本质是堆叠存储“历史 寄存器状态”。而当前没有入栈的寄存器状态，才是真正的当前上下文。&lt;/p&gt;
&lt;p&gt;因此，很多古代协程库的做法，是栈协程“句柄” 上，开辟一个数百字节的空间。用于存放当下的CPU寄存器的数值。
上下文切换的时候，就是把当前 cpu 寄存器拷到句柄空间，然后从新协程的句柄空间里把寄存器的值一个一个读回来。&lt;/p&gt;
&lt;p&gt;这种做法，是认可 “CPU寄存器数值的集合” 是当前上下文。栈不过是其中一个寄存器指向的一块内存区域，没什么特别的。&lt;/p&gt;
&lt;p&gt;但是，boost.fcontext 另辟蹊径。他唯一指定 栈为协程的正统核心。当前的 cpu 寄存器状态，可以通过“调用 上下文切换” 函数，变成 上一层的 “历史状态”。&lt;/p&gt;
&lt;p&gt;于是本层所要做的，就只是切换栈。在切换栈前，也只须将本层寄存器状态入栈。切换后，再将寄存器状态出栈。&lt;/p&gt;
&lt;p&gt;因此，在 boost.fcontext 眼里，代表协程正统的，不是那个存储了几百个字节的寄存器数值的句柄空间，而是 栈顶指针。&lt;/p&gt;
&lt;p&gt;而用于引用协程的那个句柄， fcontext_t 结构，不过就是存储了一个栈顶指针。
而不像 ucontext_t 那样，好家伙洋洋洒洒数百字节体积。&lt;/p&gt;
&lt;p&gt;这就是对“何谓上下文”的理解理念不同带来的设计差异。&lt;/p&gt;
&lt;p&gt;这点设计差异，造成了数据结构的不同。数据结构都不同了，自然上下文切换的代码也不尽相同了。正是所谓的，数据结构决定了算法。&lt;/p&gt;
&lt;p&gt;来个上下文切换代码看看&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/context_switch_code.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;作为对比，看下 ucontext 系是怎么做上下文切换的：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ucontext_code_swapcontext.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这就是不同的设计理念带来的差异。&lt;/p&gt;
&lt;p&gt;ucontext 认为 cpu寄存器是上下文，栈只是其中一个寄存器所引用的附属上下文。
而 boost.fcontext 则认为，栈就是上下文的全部。包括了所有的寄存器历史。&lt;/p&gt;
&lt;p&gt;&lt;em&gt;所谓寄存器的历史，是说进行函数调用的时候，编译器会生成入栈指令保留寄存器的数值，以便函数返回后能恢复这些寄存器的值。于是在调用链上，每一层调用帧上面都保留了一份寄存器的“快照‘&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;既然寄存器的快照就在栈上留着，那只要把当前的状态再“压栈”一次。那么所有的上下文，不就都用一个栈顶表达了吗？&lt;/p&gt;
&lt;p&gt;显然我们会发现，将栈视为协程的核心，能极大的简化代码。&lt;/p&gt;
&lt;p&gt;这点差异，还影响了 make_context 的设计。&lt;/p&gt;
&lt;h1 id=&#34;新建协程&#34;&gt;新建协程&lt;/h1&gt;
&lt;p&gt;一个协程上下文切换库，只需要编写3个函数&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;上下文切换&lt;/li&gt;
&lt;li&gt;新上下文创建&lt;/li&gt;
&lt;li&gt;新上下文的出生点&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;其中，新建上下文的出生点代码，是不需要暴露给用户的内部使用代码。另外两个，是作为库接口的形式存在的。&lt;/p&gt;
&lt;p&gt;上下文的切换，在上节已经赘述过了。就是当前状态 push 入栈。然后切换栈顶，然后 pop 出栈。大功告成。&lt;/p&gt;
&lt;p&gt;傻瓜式的代码。&lt;/p&gt;</description>
    </item>
    <item>
      <title>链接到 ucrtbase.dll</title>
      <link>https://microcai.org/2024/12/23/link-to-ucrtbase-dll.html</link>
      <pubDate>Mon, 23 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/23/link-to-ucrtbase-dll.html</guid>
      <description>&lt;p&gt;使用 vc6.0 以后的 VS 编译器，最恼火的一点就是生成的 exe 依赖 msvcrXXX.dll。
其中 XXX 是个版本号。而且 msvcrXXX.dll 系统是不自带的。&lt;/p&gt;
&lt;p&gt;于是每个 exe 都得带上 vcredist.exe 安装程序。&lt;/p&gt;
&lt;p&gt;过于蛋疼。&lt;/p&gt;
&lt;p&gt;正统的解决方法是改使用静态C库。&lt;/p&gt;
&lt;p&gt;但是会带来二进制体积暴涨的问题。&lt;/p&gt;
&lt;p&gt;十分的怀念 VC6.0 可以生成exe 依赖 msvcrt.dll， 不带版本号那种。而不带版本号的那个，每个 windows 都会自带。&lt;/p&gt;
&lt;p&gt;有比较多的偏门方式，可以在 vc6 以后的版本继续链接到 msvcrt.dll 。但是一来是偏方，而来在 vs2017 以后这些偏方也没用了。&lt;/p&gt;
&lt;p&gt;后来对此也不甚钻研了，直接无脑静态链接了。&lt;/p&gt;
&lt;p&gt;最近，突然又关心起 msvcrt 问题，因为用了下 LLVM MinGW。然后在 readme 里看到了 UCRT 介绍。&lt;/p&gt;
&lt;p&gt;UCRT？ UCRT 是啥？&lt;/p&gt;
&lt;p&gt;原来微软也发现大家不爽带版本号的 msvcrXXX.dll。于是用 C++ 以 extern &amp;ldquo;C&amp;rdquo; 的方式重写了它的 C 运行时。
这个重写的新C运行时就是 UCRT。每个 win 都会带上。名为 ucrtbase.dll 和 Debug 版的 ucrtbased.dll。&lt;/p&gt;
&lt;p&gt;连这个UCRT的，还有新的 vcruntimeXXX.dll。而过去 C++ 运行时是 msvcpXXX.dll 。&lt;/p&gt;</description>
    </item>
    <item>
      <title>boost.fcontext 为何快？</title>
      <link>https://microcai.org/2024/12/18/why-boost-fcontext-is-fast.html</link>
      <pubDate>Wed, 18 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/18/why-boost-fcontext-is-fast.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/12/17/dig-into-libco.html&#34;&gt;批评 libco&lt;/a&gt; 的 上下文切换代码的时候，我曾经说，协程的上下文切换代码，并不需要恢复所有的寄存器。
只需要恢复调用约定里规定的 “非易失性寄存器”。&lt;/p&gt;
&lt;p&gt;只有操作系统进行抢占式调度的时候，才需要恢复所有的寄存器。因为抢占式调度，可以在任何时间任何地方中断线程。如果不恢复所有寄存器，则在线程的角度看来就是寄存器的值可以任何时间任何地方突然“自主改变”。&lt;/p&gt;
&lt;p&gt;而由用户执行的协程调度则不然。上下文切换，一定是代码里“主动”调用某个控制权转移接口实现的。&lt;/p&gt;
&lt;p&gt;而这个控制权转移接口，在编译器看来，不过是一次再正常不过的外部函数调用。只要按照约定，准备好寄存器。。 并且在它返回的时候，自主恢复易失性寄存器。&lt;/p&gt;
&lt;p&gt;是的没错，调用它的地方，本来就假定易失性寄存器的数值会改变。&lt;/p&gt;
&lt;p&gt;因此，在协程的上下文切换函数里，根本没有任何必要恢复易失性寄存器的内容。只需要恢复非易失性寄存器即可。&lt;/p&gt;
&lt;p&gt;为了验证我的设想，我写了一个 zcontext 进行了验证。
这个 zcontext 已提交进 uasync 代码仓库，详情看 &lt;a href=&#34;https://github.com/microcai/iocp/commit/e2d6da2a7cb208a8ed1fcdda6d835ccef193b3c4&#34;&gt;commit&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;不过我这上下文切换，只恢复了8个非易失性通用寄存器。对16 个 MMX 寄存器，还有 AVX 寄存器，都没有进行恢复。
不知道会不会出问题。于是就仔细的研读了 boost.context 的汇编代码。希望研究下怎么恢复 SSE 和 AVX 寄存器。&lt;/p&gt;
&lt;p&gt;注：boost.context 里负责上下文切换的 汇编写的 api 叫 fcontext 。&lt;/p&gt;
&lt;p&gt;结果发现 fcontext 的做法和我的不能说完全一样，简直是一模一样。&lt;/p&gt;
&lt;p&gt;无非是我用了 一排 push + 一排 pop 做的切换，而它的代码使用了 mov 指令。但都是等价的。&lt;/p&gt;
&lt;p&gt;也只恢复了非易失性通用寄存器和 2个 80387状态寄存器。&lt;/p&gt;
&lt;p&gt;这下总算完全理解为啥 boost.context 称自己的性能天下无敌了。&lt;/p&gt;
&lt;p&gt;因为确实没有比这更快的上下文切换方式了。&lt;/p&gt;
&lt;p&gt;由此可见，libco 的作者还真是水货一个。他引以为傲的那段汇编代码，就是一坨羊粪。&lt;/p&gt;</description>
    </item>
    <item>
      <title>点评 腾讯 的 协程库 libco</title>
      <link>https://microcai.org/2024/12/17/dig-into-libco.html</link>
      <pubDate>Tue, 17 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/17/dig-into-libco.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;libco 是 腾讯开源的一个协程库。噱头很大，动不动就是承载了微信后台亿万并发。
敢说个不马上被喷成狗头。但是我偏就是要对这些光有名头没啥技术的东西祛魅。&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://microcai.org/2024/12/16/dig-into-coroutine-lib.html&#34;&gt;上一片文章&lt;/a&gt; 里，点评了云风的 coroutine库，其中提到了 libco 犯了和云风一样的错。&lt;/p&gt;
&lt;p&gt;其实 libco 的错误要比云风还要多的多。&lt;/p&gt;
&lt;p&gt;废话不多说，接下来点评 libco&lt;/p&gt;
&lt;h1 id=&#34;libco-错在哪里&#34;&gt;libco 错在哪里&lt;/h1&gt;
&lt;p&gt;首先错误的，仓库上一篇，他和云风的错误是一样的。表述相同的部分就不特别说明了。&lt;/p&gt;
&lt;h2 id=&#34;1-协程库不应该干涉程序结构&#34;&gt;1 协程库不应该干涉程序结构&lt;/h2&gt;
&lt;p&gt;但是 libco 的此进入非彼侵入。云风的侵入，是需要永久性的携带 &lt;code&gt;struct schedule *S&lt;/code&gt;,
而 libc 的侵入，则是，它根本就不让你正常的用阻塞的思维模式设计你的代码结构。&lt;/p&gt;
&lt;p&gt;我们那它源码里自带的 example_echosrv.cpp 举例&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/libco_code1.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这是它一个建议的 echo server。前面介绍 iocp4linux 的时候，我就贴过正统代码。
算了，还是直接给个对比吧。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;alt text&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/compare_libco_uasync.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;图片里两端代码，下面的是正统协程库写的 echo server 里的 accept 循环。
而上面那段则是 libco 里的例子。&lt;/p&gt;
&lt;p&gt;正如我图片里的吐槽那样，腾讯的 libco 在编写代码的时候，很容易陷入不知所谓的境地。&lt;/p&gt;
&lt;p&gt;这就是因为它库设计的缺陷，所以必须要用很绕的方式组织代码逻辑。&lt;/p&gt;
&lt;h2 id=&#34;2-协程库不应该强依赖一个调度器&#34;&gt;2 协程库不应该强依赖一个调度器&lt;/h2&gt;
&lt;p&gt;还是刚刚腾讯自己写的 example_echosrv.cpp 例子。
这次是 main 函数。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/libco_code2.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这不仅仅是依赖调度器了，这是必须，也只能使用 libco 的事件循环。&lt;/p&gt;
&lt;p&gt;如果云风的库只能算对你壁咚，那腾讯的库就是把你裤子都扒光了后入。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当然，不可否认一些人有网红膜拜症，非要被玩一把才开心。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;当然，如果他的库已经实现的比较完善，那么使用他的事件循环，调用他封装好的 IO api，也未尝不可以接受。神神曾经说过，被强奸的时候，反抗不了，就要学会享受。&lt;/p&gt;</description>
    </item>
    <item>
      <title>点评 云风 的 C库 coroutine</title>
      <link>https://microcai.org/2024/12/16/dig-into-coroutine-lib.html</link>
      <pubDate>Mon, 16 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/16/dig-into-coroutine-lib.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;在知乎上看到两篇 吹嘘 云风的 coroutine 库的文章。&lt;/p&gt;
&lt;p&gt;人啊就是这样的，出名了以后，就是垃圾也有人吹捧。&lt;/p&gt;
&lt;p&gt;今天来点评下，云风的 coroutine 到底垃圾在哪里。又或者说，一个优秀的协程，应该优秀在哪里。&lt;/p&gt;
&lt;h1 id=&#34;云风错在哪里&#34;&gt;云风错在哪里&lt;/h1&gt;
&lt;p&gt;首先一个优秀的协程库，要做到“自然”。&lt;/p&gt;
&lt;p&gt;什么是“自然”呢？就是要做到尽量不改变原来写同步阻塞IO逻辑的时候的代码。&lt;/p&gt;
&lt;p&gt;因此引出第一错：&lt;/p&gt;
&lt;h2 id=&#34;1-协程库不应该侵入-api-设计&#34;&gt;1 协程库不应该侵入 API 设计&lt;/h2&gt;
&lt;p&gt;要使用云风的协程，被调度的协程必须有如下的函数签名&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;coroutine_function&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;struct&lt;/span&gt; schedule &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;S, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; arg);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;注意到那个 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数了吗？要使用协程，必须带上这个参数。&lt;/p&gt;
&lt;p&gt;哪怕本层级的函数并不直接调用 IO, 也就是不会直接用到 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数，他也得带上，并将 &lt;code&gt;struct schedule *S&lt;/code&gt; 传给所有他要调用的函数。&lt;/p&gt;
&lt;p&gt;也就是整个程序所有的函数都得带上 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;这也是 asio 的有栈协程设计失败的地方。一旦使用了有栈协程，所有的函数都得加上 &lt;code&gt;asio::yield_context&lt;/code&gt; 参数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;如果只是某个会调用 IO 的函数需要带上这个 休眠器 还好。但是假设这样的调用链条&lt;/p&gt;
&lt;p&gt;A -&amp;gt; B -&amp;gt; C -&amp;gt; D, 最终在 D函数里调用了  async_read();&lt;/p&gt;
&lt;p&gt;那显然，为了让整条路径能实现逐级传递 &lt;code&gt;struct schedule *S&lt;/code&gt;, 必然会让这条调用链上的所有函数都带上 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数。&lt;/p&gt;</description>
    </item>
    <item>
      <title>基于 ucontext &#43; iocp4linux 的超简协程库</title>
      <link>https://microcai.org/2024/12/15/ucontext-based-uasync.html</link>
      <pubDate>Sun, 15 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/15/ucontext-based-uasync.html</guid>
      <description>&lt;p&gt;虽然说，使用 异步最佳的实践是使用协程。&lt;/p&gt;
&lt;p&gt;然而 c++20 的协程并不总是可用的。总不能说，不能更新编译器的地方就不配写代码吧。&lt;/p&gt;
&lt;p&gt;因此，我在上一篇文章里说道，可以继续忍受回调地狱。或者使用有栈协程。&lt;/p&gt;
&lt;p&gt;当然，如果使用 asio ， 那么一切问题都不存在。asio 支持 有栈协程，无栈协程，daff‘s device 协程，还有最基础的，回调模式。
asio 简直就是个“宇宙级” 的异步库。&lt;/p&gt;
&lt;p&gt;然而，asio 也并不总是可用。&lt;/p&gt;
&lt;p&gt;于是，基于 ucontext 的一个超简协程库就应运而生。&lt;/p&gt;
&lt;p&gt;首先，这个不是一个独立的库，他其实顺手带在 uasync 里。作为  universal_fiber.h 头文件提供。&lt;/p&gt;
&lt;p&gt;就隐藏在 iocp4linux 的 example 代码里。
见 &lt;a href=&#34;https://github.com/microcai/iocp/blob/master/example/echo_server/echo_server_stackfull.c&#34;&gt;echo_server_stackfull.c&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;没错，这次是个 C 代码。尽管我非常讨厌 C。&lt;/p&gt;
&lt;p&gt;这个库，只是为了演示如何将 proactor 和有栈协程给结合起来。虽然我本人建议最好使用 c++20 的协程。但是总有人是升级不了编译器的。
因此我再三思考后，决定还是写一个小 demo 来演示 proactor 和有栈协程 如何极便捷的结合。&lt;/p&gt;
&lt;p&gt;对于这么一个简单的 echo server 例子，作为对比，同文件夹下的 echo_server_callback.cpp 就是基于回调的。可以直观感受下，基于回调和基于协程的代码可读性。&lt;/p&gt;
&lt;h1 id=&#34;先看有栈和无栈例子对比&#34;&gt;先看有栈和无栈例子对比&lt;/h1&gt;
&lt;p&gt;这个是 echo server 左边有栈协程和右边无栈协程的 accept 循环的代码对比
&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ucontext_code4.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;不能说毫无差别，简直可以说是一模一样&lt;/p&gt;
&lt;p&gt;也就是说有栈和无栈，是只存在底层工作机制的差异&lt;/p&gt;
&lt;p&gt;没有使用上的差异。&lt;/p&gt;
&lt;p&gt;这就是 universal_fiber.h 和 universal_async.hpp 的威力。&lt;/p&gt;
&lt;p&gt;关于那个无栈协程 universal_async.hpp 的分析，参考 &lt;a href=&#34;https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html&#34;&gt;这篇文章&lt;/a&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入异步IO 第二篇： 正确使用 IOCP，正确设计 proactor</title>
      <link>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</link>
      <pubDate>Sat, 14 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;reactor-和-proactor&#34;&gt;Reactor 和 Proactor&lt;/h1&gt;
&lt;p&gt;ACE 作者当年提出了数个高性能网络IO的模型，其中将这些模型总结为 Reacto 和 Proactor。如果按字母意思翻译，
则称为 反应器 和前摄器。&lt;/p&gt;
&lt;p&gt;但是，我更愿意使用更精准的汉语表达：多路复用模式 和 重叠IO模式。&lt;/p&gt;
&lt;h2 id=&#34;多路复用模式&#34;&gt;多路复用模式&lt;/h2&gt;
&lt;p&gt;前一篇文章说道，要想实现单线程并发IO, 内核必须要提供的2个机制。在 多路复用模式下，要求的机制就是&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 和 &lt;strong&gt;无阻塞IO操作&lt;/strong&gt;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;无阻塞IO操作&lt;/strong&gt; 要求内核在IO不能立即完成的情况下，不能挂起调用线程，而是返回错误。但是此时代码不应该进入无限重试，而是等待内核的通知。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 如果一个 IO 操作接下来可以无阻塞立即执行，则通知程序，现在可以干活而不会失败了。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;比如我写一个 server，调用 read() 读取客户端发送的数据。如果客户端还未发送数据。则内核会挂起线程直到对方发送数据。然后 read 就执行成功并返回了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入理解异步IO</title>
      <link>https://microcai.org/2024/12/13/in-deepth-async.html</link>
      <pubDate>Fri, 13 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/13/in-deepth-async.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;线程的由来&#34;&gt;线程的由来&lt;/h1&gt;
&lt;p&gt;现在的程序员大部分都是新世纪后出生的。所以早就忘记了线程的设计初衷了。我看到大部分新世纪程序员都说线程是为了并发，为了压榨cpu的性能。&lt;/p&gt;
&lt;p&gt;其实多线程压榨 cpu 的性能，是最近十几年才有的。而线程的历史，和操作系统一样古老。
计算机诞生的前半个世纪，CPU都是单核的。那时候就已经有了多线程。&lt;/p&gt;
&lt;p&gt;所以，线程的最初真正作用，实际上出乎现在的程序员的意料：是为了实现异步IO。&lt;/p&gt;
&lt;h2 id=&#34;dos-下的-io&#34;&gt;DOS 下的 IO&lt;/h2&gt;
&lt;p&gt;在个人电脑的上古时代，一个打字员的日常工作，是打字，然后 按下键盘上的 Ctrl-S。接着去泡杯茶去喝。&lt;/p&gt;
&lt;p&gt;当 wps 要将文档存入软盘，意味着这段时间，整台电脑都处于“不可操作”的状态。
直到软驱磁头吭呲吭呲的干完活，当前的应用才会复活，能继续执行其他任务了。&lt;/p&gt;
&lt;p&gt;为啥会这样呢？因为 DOS 是一个单任务的操作系统，不支持多线程。这就意味着，DOS 不支持异步 IO。WPS要写磁盘，就只能等待 DOS 完成文件写入。
期间整个电脑都无法干其他工作。&lt;/p&gt;
&lt;p&gt;这个问题，直到“多任务系统”的出现才解决。当然，多任务系统，出现的比 DOS 早多了，只不过，引入 PC 领域要晚的多。一直到 windows 出现。&lt;/p&gt;</description>
    </item>
    <item>
      <title>批量提交IO提升性能</title>
      <link>https://microcai.org/2024/12/10/io_batching-boost-performance.html</link>
      <pubDate>Tue, 10 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/10/io_batching-boost-performance.html</guid>
      <description>&lt;p&gt;在基本完成 iocp4linux 后，我抽空在 &lt;a href=&#34;https://wiki.radxa.com/Rockpi4&#34;&gt;rockpi&lt;/a&gt; 上测了下性能。&lt;/p&gt;
&lt;p&gt;使用仓库里自带的例子  test/web_server/server.cpp，我测得了大约 6000req/s 的性能。&lt;/p&gt;
&lt;p&gt;还不错。但是和 PC 上超过十万的性能相比，有那么点。。。弱鸡。&lt;/p&gt;
&lt;p&gt;但是我通过 htop 注意到了一点。wrk 压测的时候， cpu1 是 cpu 100%。而且都是 红色的。说明cpu 都花在内核时间上了。
这也是 io_uring 很牛逼的原因：活都让内核干了。&lt;/p&gt;
&lt;p&gt;==。&lt;/p&gt;
&lt;p&gt;rockpi 是个6核的soc, 其中 cpu1-cpu4 （我设定 htop 的 cpu 从 1 开始数。）是个 1.4Ghz 的小核。cpu5，cpu6 才是 1.8Ghz 的大核。&lt;/p&gt;
&lt;p&gt;这 不仅仅一核有难，5核围观。这特么干活的还是个小核。&lt;/p&gt;
&lt;p&gt;于是果断找原因，发现是中断亲和性的设定问题。将中断迁移到 cpu5 后，测试发现干活的就是 1.8Ghz 的大核啦。&lt;/p&gt;
&lt;p&gt;然后性能飙到超过 9000req/s。&lt;/p&gt;
&lt;p&gt;之前测试的性能忘记记录了，这次随手截图留存了。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/iocp4linux_perf_1.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;嘿嘿，果然给力。这优化。还是免费的。&lt;/p&gt;
&lt;p&gt;就在我沾沾自喜的时候，我又随手测试了以下 老中医写的 proxy_server。它里面带了一个简单的 http server。
wrk 压测以下，我了个去的。轻轻松松 1.6万req/s。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/asio_test1_perf.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;asio 你大爷还是你大爷！&lt;/p&gt;
&lt;p&gt;于是我琢磨着进行优化。&lt;/p&gt;
&lt;p&gt;我想到了 io_uring 提交 IO 的两步曲：&lt;/p&gt;</description>
    </item>
    <item>
      <title>超轻量级 IOCP 协程库</title>
      <link>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</link>
      <pubDate>Sun, 08 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/12/04/iocp-on-linux.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我提出了 &lt;a href=&#34;https://github.com/microcai/iocp&#34;&gt;iocp4linux&lt;/a&gt; 。&lt;/p&gt;
&lt;p&gt;在编写 iocp4linux 的过程中，我需要写一些测试代码。&lt;/p&gt;
&lt;p&gt;一开始，我随便的找了一个基于 IOCP 的 echo test 和一个简单的 web server。
首先确保这弄来的例子能在 windows 上编译通过。&lt;/p&gt;
&lt;p&gt;然后修改 ifdef _WIN32守卫，在 linux 平台上改为使用 iocp.h 头文件。&lt;/p&gt;
&lt;p&gt;然后很轻松的就移植到 linux 上了。&lt;/p&gt;
&lt;p&gt;但是，我对于这些 C 风格的 demo 并不满意。因为我完全改不动他们的代码。&lt;/p&gt;
&lt;p&gt;于是，我想着，何不写一个超级轻量级的一个封装库？
这个库，应该做到跨平台 —— 指能同时兼容原版 windows.h和 iocp.h。然后代码尽量短小，同时又足够易用。&lt;/p&gt;
&lt;p&gt;最后。我折腾出了一个超轻量级的协程库。&lt;/p&gt;
&lt;p&gt;废话不说，先看一段 异步 accept 的代码：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/awaitable_overlapped.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;在红框处，使用的是 windows 上的异步 accept 。
在 AcceptEx 调用的时候，传入了一个 ov 对象。
这个 ov 对象，类型是 awaitable_overlapped 。
awaitable_overlapped 可以隐式转换为 &lt;code&gt;WSAOVERLAPPED*&lt;/code&gt; 从而被 AcceptEx 所接受。&lt;/p&gt;
&lt;p&gt;由于是异步 IO ， 这时代码会继续向下运行。一般如果是在非协程的代码里。此时就应该返回函数。&lt;/p&gt;
&lt;p&gt;然后把 accpet 的后续逻辑，放到 调用 &lt;code&gt;GetQueuedCompletionStatus&lt;/code&gt; 的事件循环里了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>IOCP 移植到Linux上</title>
      <link>https://microcai.org/2024/12/04/iocp-on-linux.html</link>
      <pubDate>Wed, 04 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/04/iocp-on-linux.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;windows 高性能IO使用的是 proactor 模型，而古代 Linux 上则是 reactor 模型。&lt;/p&gt;
&lt;p&gt;因此跨平台的网络库，通常会选择实现为其中一种模型，然后在另一个平台上使用模拟。
比如 asio 使用 proactor 模型。Linux 上使用 epoll 模拟。
又比如 libevent 使用 reactor 模型， windows 上使用 iocp 模拟。&lt;/p&gt;
&lt;p&gt;而将 iocp 模拟为 epoll 的库，就是 &lt;a href=&#34;https://github.com/piscisaureus/wepoll&#34;&gt;wepoll&lt;/a&gt; 了。&lt;/p&gt;
&lt;p&gt;但是，reactor 比较是一种比较落后的模型。因此，进行跨平台封装为 proactor 实际上是更先进的做法。&lt;/p&gt;
&lt;p&gt;虽然已经有 asio 这种 proactor 库了，但是毕竟 asio 是一个比较重量级的库。一种轻量级的 proactor 库
也是非常有市场的。&lt;/p&gt;
&lt;p&gt;更何况，既然有 wepoll 这种把 Linux api 弄到 windows 上的库，那没有 Linux IOCP 就说不过去了。&lt;/p&gt;
&lt;p&gt;于是我决定，开发一个 Linux 版的 IOCP 库。这样方便使用 IOCP 开发的各种软件可以方便的迁移到 Linux 平台。而无需重写。&lt;/p&gt;
&lt;h1 id=&#34;如何实现呢&#34;&gt;如何实现呢？&lt;/h1&gt;
&lt;p&gt;如果是在很久以前，这件事其实还是比较复杂的。然而，嘿嘿。从 linux 5.1 开始，一个崭新的名为 io_uring 的系统接口诞生了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>用iouring扩展asio</title>
      <link>https://microcai.org/2024/11/21/extending-asio.html</link>
      <pubDate>Thu, 21 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/21/extending-asio.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;什么叫扩展asio？
Beast给Asio增加了 HTTP 协议，不叫扩展asio。那什么叫扩展asio？
举个例子，给 asio 的 socket 对象，基于io_uring提供的 IORING_OP_SHUTDOWN 增加 async_shutdown() 接口，就算扩展asio。因为原本asio并没有异步shutdown功能。而且这个功能并不能靠组合原有的asio接口实现。这就叫扩展asio。&lt;/p&gt;
&lt;p&gt;扩展asio, 又不能修改asio的代码。看起来有点难办。
好在，asio的设计也是有一定的扩展性的，并非完全依赖修改源码实现扩展。
但是不可避免的，需要使用 asio::detail:: 名字空间下的非公开接口。&lt;/p&gt;
&lt;p&gt;那么，就从 async_shutdown 开始，讲解如何扩展asio吧！&lt;/p&gt;
&lt;h1 id=&#34;接口形式&#34;&gt;接口形式&lt;/h1&gt;
&lt;p&gt;不修改asio代码的大前提下，要给一个对象增加一个 async_shutdown() 的成员函数那是痴人说梦。语言上就禁了此路。&lt;/p&gt;
&lt;p&gt;不过，有两种绕过的做法&lt;/p&gt;
&lt;p&gt;其一。写一个新的socket对象，自 asio::ip::tcp::socket 继承。然后增加一个成员函数。缺点是所有使用 socket 的地方都得修改一下类型。有了IDE的重构大法，实际上为了能异步关闭而进行的迁移并不算特别大的工作量。但是如果有不需要牵一发而动全身的修改，会更好。
其二。写一个全局函数，接受一个 asio::ip::tcp::socket 并将他异步关闭。&lt;/p&gt;
&lt;p&gt;第二个方法，不需要对整个项目进行大手术。只需要在需要异步关闭的地方，将原来的同步关闭 ( &lt;code&gt;socket.shutdown();&lt;/code&gt;)，替换为  &lt;code&gt;co_await async_shutdown(socket, defered);&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;从设计美学上来说，第二个方法更好。&lt;/p&gt;
&lt;h1 id=&#34;操作系统接口&#34;&gt;操作系统接口&lt;/h1&gt;
&lt;p&gt;扩展asio, 并不是使用asio现有接口去实现一个功能。比如beast利用 asio现有的socket接口就能实现在其基础上增加 HTTP 协议支持。
我们要给 asio 的 socket 增加异步关闭功能，是实打实的让asio多了原本不存在的功能。那么显然，这样的功能，首先我们得问一问，操作系统支持吗？
如果操作系统不支持一个功能，我们想破天也没法给asio扩展出这个功能。&lt;/p&gt;
&lt;p&gt;答案是，异步关闭socket只有io_uring支持了。windows 上虽然也支持异步关闭，但是需要使用 WSAEventSelect + WSAWaitForMultipleEvents + shutdown 组合使用。IOCP不支持异步关闭。没有能传 overlaped* 的 WSAShutdown 版本。&lt;/p&gt;
&lt;h1 id=&#34;asio-的接口组织结构&#34;&gt;asio 的接口组织结构&lt;/h1&gt;
&lt;p&gt;asio 暴露给用户的接口为2种对象，其一为 executor ，其二为 io_object. executor 一般而言就是 asio::io_context。而 io_object 则通常就是 socket 咯。&lt;/p&gt;</description>
    </item>
    <item>
      <title>重叠IO（proactor）是最理想的IO模型</title>
      <link>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</link>
      <pubDate>Tue, 19 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</guid>
      <description>&lt;p&gt;reactor 和 proactor ， 这种毫无联系的英文专用名词，很容易把人弄晕。&lt;/p&gt;
&lt;p&gt;回归正途，使用精确的汉语描述，而非翻译，则正确的说法是：&lt;/p&gt;
&lt;p&gt;多路复用IO 和 重叠 IO 模式。&lt;/p&gt;
&lt;p&gt;所谓多路复用，顾名思义，就是好几个IO复用。。。 复用了谁？复用了线程。
它对比的是最传统的UNIX网络编程： 一个连接一个线程。并发就要开多线程。连接多了，线程就多，系统压力非常大。
而多路复用，则可以让一个线程处理多个连接。这就是复用的含义。为了实现复用，首先IO是非阻塞的。因为如果阻塞了线程，其他连接上的数据不就没法处理了么。既然非阻塞，那就会出现网络数据没准备好，就一直返回 EAGAIN 错误。一直返回难道一直重试吗？显然不现实。所以就有了一个 多路复用器。这个多路复用器最早是 select() 调用。后来是 poll() 最后是 epoll().
而重叠IO,顾名思义，就是 IO 操作是重叠的。和什么重叠？当然是和你当前的线程是重叠的。
也就是，向系统提交一个 IO 操作， 系统就会在“后台”默默的干苦力，当前线程可以立即执行其他任务。不会被阻塞。他和多路复用模式的区别是，多路复用模式，如果会阻塞，内核就返回会阻塞，而不是在后台默默干活。而 重叠IO 则即不会阻塞，也不会返回“请重试”。而是在后台开始默默的进行处理。这个IO的处理，和你程序本身的逻辑，是重叠进行的。所以叫重叠IO。&lt;/p&gt;
&lt;p&gt;话又说回来了，系统是在后台干活了，你得知道他啥时候干好了吧？总不能两眼一摸黑，不知道了吧。
因此，系统需要一个通知机制。Linux 这边，曾经有一种叫 AIO 的东西，它用 “信号” 来通知 IO 完成了。而如今 Linux 使用 io_uring 的 无锁列队 来完成通知。而 windows 则使用 一个叫“完成队列”的东西来通知，当然也可以使用 窗口消息来通知结果。&lt;/p&gt;
&lt;p&gt;不管是 win 的窗口消息，还是linux的 AIO ，在实践中都被人抛弃不用了。因此不讨论这些。&lt;/p&gt;
&lt;p&gt;我们讨论 IO完成端口，和 io_uring, 他们本质上是一样的，就是提供一个异步队列，然后应用层可以使用 一个或多个线程，去读取这个队列获得完成通知。每一个IO操作，都对应一个完成通知。
因此，重叠IO模式，其实和传统的编程思路是一致的：每调用一个函数，就获得一个返回值。
无非是，这个返回不是通过 ret 指令返回，返回结果也不是通过 EAX 寄存器返回。
而是存放到了一个消息队列里。&lt;/p&gt;
&lt;p&gt;但是，操作请求和结果返回，是一一对应的。这是一种非常自然的概念。
自然而然的，在编程上，就可以设计为 IO发起 + 完成回调。
库的作用，就是封装 系统的 IO api ，然后将 IO完成消息转化为 完成回调。
有了 IO发起+完成回调。很自然的，程序就可以组织为一种 协程结构。 发起IO操作，返回一个 promise . IO完成就是让 promise 完成状态。
想同步IO结果，只要 await 这个 promise 就可以了。
非常的容易理解，而且封装起来也非常的轻松。用起来简直就是爽到high起。&lt;/p&gt;</description>
    </item>
    <item>
      <title>真正的重叠IO</title>
      <link>https://microcai.org/2024/11/18/real-overlaped-io.html</link>
      <pubDate>Mon, 18 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/18/real-overlaped-io.html</guid>
      <description>&lt;p&gt;不知有没有人想过，为何微软将windows 的异步API称为“重叠IO”而不是异步IO。&lt;/p&gt;
&lt;p&gt;在我看来，重叠IO和异步IO的区别，主要在于发起IO后的动作。&lt;/p&gt;
&lt;p&gt;重叠IO, 发起 IO 后，继续执行应用层的逻辑。应用可以选择在任何何时的地点再选择同步（阻塞等待 or 异步等待）IO的结果。
异步IO, 发起 IO 后，立即挂起当前业务逻辑（也就是立即非阻塞等待 IO 结果），回到事件循环，以便执行其他业务逻辑。&lt;/p&gt;
&lt;p&gt;放到协程的设计角度，重叠 IO 相当于这样使用&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;async&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;function&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;file&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;read&lt;/span&gt;(...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    ... &lt;span style=&#34;color:#a6e22e&#34;&gt;干点不依赖&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;结果的事情&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_result&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;await&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    ... &lt;span style=&#34;color:#a6e22e&#34;&gt;干需要&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;操作结果的事情&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;而异步 IO, 则是这样使用&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; function &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; read_result &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; co_await file.&lt;span style=&#34;color:#a6e22e&#34;&gt;async_read&lt;/span&gt;(...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// do other logic.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以看出来，重叠 IO 在发出 IO 操作后，可以继续执行其他逻辑。只有当确实需要数据的时候，再进行等待。
而异步IO模式下，发出IO后，必须立即挂起当前协程等待IO完成。&lt;/p&gt;
&lt;p&gt;那么，这两种差异，对现实中的程序有什么影响呢？&lt;/p&gt;
&lt;p&gt;我们先考虑一个最简单的应用： 静态 web 服务器。&lt;/p&gt;
&lt;p&gt;在静态web服务器里，最核心的处理逻辑，就是找到用户要下载的文件，然后将文件发送给客户端。伪代码如下&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; handle_send_file(&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; target, &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; socket)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt; buffer[&lt;span style=&#34;color:#ae81ff&#34;&gt;65536&lt;/span&gt;];
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    fs&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;file f(target, flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;binary&lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt;flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;open);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;long&lt;/span&gt; total &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt;(;;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; read_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; f.async_read_some(buffer);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (read_size &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            &lt;span style=&#34;color:#66d9ef&#34;&gt;break&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        total &lt;span style=&#34;color:#f92672&#34;&gt;+=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; socket.async_write_some(buffer, read_size);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;co_return&lt;/span&gt; total;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个代码里，主要的逻辑就是 循环读取文件，然后发送。&lt;/p&gt;</description>
    </item>
    <item>
      <title>不要 new 一个 char 数组当缓冲区</title>
      <link>https://microcai.org/2024/11/16/do-not-new-a-buffer.html</link>
      <pubDate>Sat, 16 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/16/do-not-new-a-buffer.html</guid>
      <description>&lt;p&gt;性能调优是一个有魔力的工作。最近研究到了 &lt;code&gt;std::pmr::&lt;/code&gt;, 就想着看能否有些老代码能改进改进，提高下性能。&lt;/p&gt;
&lt;p&gt;但是，测试的时候，发现还是有一些路径的效率不理想。&lt;/p&gt;
&lt;p&gt;经过好久的排查，最终定位代码到这么一行&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; buffer_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; buffer &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;make_unique&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;[]&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;(buffer_size);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;好家伙，原来 &lt;code&gt;make_unique&amp;lt;char[]&amp;gt;&lt;/code&gt; 这么慢的吗？&lt;/p&gt;
&lt;p&gt;原来 make_unique 不单单是 分配了 buffer_size 个字节的内存，同时还 构造了如此数量的 char 对象。
问题是我这只是个 buffer, 不需要初始化啊！&lt;/p&gt;
&lt;p&gt;继续查看生成的汇编代码，发现 make_unique 还是很聪明的，并没有在一个 for 循环里调用5百万次 char 的构造函数。
看来第一种 for 循环五百万次赋值 0 的担忧是没了。
结果看到了汇编代码里的 &lt;code&gt;call memset@plt&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;所以说，哪怕编译器自动的把初始化代码优化为了一个  memset 调用，它还是调用了 memset ， memset 对一个 5MB 的内存，还是要花点时间的。&lt;/p&gt;
&lt;p&gt;于是我随手把代码改成了&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; buffer_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;unique_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;decltype&lt;/span&gt;(&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;free)&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; buffer(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;malloc(buffer_size), &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;free);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;测试发现性能飙升了十几倍。&lt;/p&gt;
&lt;h1 id=&#34;总结&#34;&gt;总结&lt;/h1&gt;
&lt;p&gt;在不需要初始化的 buffer 分配领域，使用 malloc 是比 new 更好的选择。&lt;/p&gt;</description>
    </item>
    <item>
      <title>用本机 clang 进行交叉编译</title>
      <link>https://microcai.org/2024/11/16/cross-compile-by-clang.html</link>
      <pubDate>Sat, 16 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/16/cross-compile-by-clang.html</guid>
      <description>&lt;p&gt;你在 A 平台上编译一份代码，编译出来的结果，在 A 平台无法运行，只能在 B 平台运行。这个就叫交叉编译。&lt;/p&gt;
&lt;p&gt;通常使用交叉编译，是因为 B 平台太弱鸡，性能无法胜任编译工作。&lt;/p&gt;
&lt;p&gt;因此大部分交叉编译，都是发生在 x86 上为 arm 编译。&lt;/p&gt;
&lt;p&gt;为了进行交叉编译，你需要使用一种专门为交叉编译而开发的工具 —— &lt;strong&gt;交叉编译器&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;在 Gentoo 上，交叉编译器可以使用工具 ”crossdev&amp;quot; 自动构建出来。&lt;/p&gt;
&lt;p&gt;比如&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code class=&#34;language-base&#34; data-lang=&#34;base&#34;&gt;crossdev -t aarch64-unknow-linux-gnu
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;最后，你会获得一系列 aarch64-unknow-linux-gnu- 打头的编译工具。其中 aarch64-unknow-linux-gnu-gcc 就是 C语言的交叉编译器。
aarch64-unknow-linux-gnu-g++ 就是 C++ 的交叉编译器。还有 aarch64-unknow-linux-gnu-ld 自然就是交叉连接器。&lt;/p&gt;
&lt;p&gt;这些工具的文件名，你可以传给编译脚本，就实现了交叉编译。&lt;/p&gt;
&lt;p&gt;如果是 CLANG ， 情况发生了一些变化。&lt;/p&gt;
&lt;p&gt;首先，你还是可以通过重新编译 clang ， 设定 clang 的目标平台，配置 clang 的安装前缀，最终获得一系列 aarch64-unknow-linux-gnu-llvm 开头的 llvm 工具链。&lt;/p&gt;
&lt;p&gt;比如 aarch64-unknow-linux-gnu-llvm-link, aarch64-unknow-linux-gnu-llvm-as . 以及 aarch64-unknow-linux-gnu-clang 和 aarch64-unknow-linux-gnu-clang++。&lt;/p&gt;
&lt;p&gt;但是，我要说但是了。这套做法，其实完全没有必要。&lt;/p&gt;
&lt;p&gt;因为 LLVM 的设计结构就决定了，你当前系统里安装的 clang 编译器，体内已经蕴含了全部受llvm支持的平台的机器代码生成能力。
而 gcc 的体内，一次只能含有一个平台的机器码生成能力，其他架构的机器码生成功能会通过条件编译排除。这是 gcc 需要专门构建交叉编译器的原因。&lt;/p&gt;</description>
    </item>
    <item>
      <title>可变模板参数包迭代</title>
      <link>https://microcai.org/2024/11/13/range-for-on-parameter-pack.html</link>
      <pubDate>Wed, 13 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/13/range-for-on-parameter-pack.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;如果你写了一个模板函数，模板函数里使用了 可变参数。比如你写了个&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Args... args);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么，要如何去访问这些可变的参数呢？&lt;/p&gt;
&lt;h3 id=&#34;方法-1&#34;&gt;方法 1&lt;/h3&gt;
&lt;p&gt;使用递归法。比如定义2个 print, 一个是单参数的，另一个是 2个模板参数的。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Arg&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Arg arg);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Arg1 arg1, Args... args)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	print(arg1);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	print(args...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在可变参的 print 里， 它首先将第一个参数调用了单参数版的 print. 接着把剩下的参数调用自身。&lt;/p&gt;
&lt;p&gt;如果剩下的参数就一个了，那么编译器也是匹配到单参数版的 print 从而结束递归。&lt;/p&gt;
&lt;h3 id=&#34;方法-2&#34;&gt;方法 2&lt;/h3&gt;
&lt;p&gt;使用 &lt;strong&gt;折叠表达式&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Args... args)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	(print_one(args), ...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个方法里，&lt;code&gt;(print_one(args), ...);&lt;/code&gt;就是所谓的 &lt;strong&gt;折叠表达式&lt;/strong&gt;。 它的意思就是把 前面的 重复一下。每次重复的时候，各使用参数包里的一个参数。&lt;/p&gt;
&lt;h3 id=&#34;方法-3&#34;&gt;方法 3&lt;/h3&gt;
&lt;p&gt;打包进 std::tuple 后使用。比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print_tuple(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;tuple&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;Args...&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; tuple_arg)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// ???
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Args... args)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	print_tuple(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;forward_as_tuple(args...));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;吼吼，那么问题来了， tuple 版本要怎么实现？&lt;/p&gt;</description>
    </item>
    <item>
      <title>把闭包变成函数指针—— trampoline 原理解析</title>
      <link>https://microcai.org/2024/11/02/lambda-to-function-pointer.html</link>
      <pubDate>Sat, 02 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/02/lambda-to-function-pointer.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;十年前，我曾经写过一个让 C 形式的回调函数支持 闭包的小转换工具, &lt;a href=&#34;https://github.com/avplayer/avboost/blob/master/include/boost/cfunction.hpp&#34;&gt;见这&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;那时候，我说过，要想把 boost.function 传给 C 接口，那这个 C 接口，必须得带一个 &lt;code&gt;void* user_data&lt;/code&gt; 的参数。&lt;/p&gt;
&lt;p&gt;比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以利用这个 cfuntion，把 &lt;code&gt;boost::function&amp;lt;int(int, int)&amp;gt;&lt;/code&gt; 给当成 callback_t 使用。
而 boost::function 本身又可以接受 lambda, boost::bind ， 从而组合出非常易用的使用方式。&lt;/p&gt;
&lt;p&gt;但是，这十年来，我也偶尔会遇到一些 C 库的 api ， 他就只能接受裸指针，不能接受 &lt;code&gt;void* user_data&lt;/code&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这就很难受了。因为没有办法传递 void*, 也就无法给回调函数设置“上下文”。也就彻底失去了上下文关联能力了。不得不将所需的
数据通过“全局变量”传递给回调函数。十分丑陋不说，还导致回调函数变成了无法重入的。&lt;/p&gt;
&lt;h1 id=&#34;转机&#34;&gt;转机&lt;/h1&gt;
&lt;p&gt;其实，如果使用 GCC 编译器，GCC 也提供一个叫 “nested function” 的功能，比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;main&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; hello &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;nested_function&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#a6e22e&#34;&gt;printf&lt;/span&gt;(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;hello = %d&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;\n&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&lt;/span&gt;, hello);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(nested_function);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个 nested_function 能访问 main 里定义的对象，算的上一种“闭包”了，但是，它仍然可以转换为不需要 void* 的裸函数指针。&lt;/p&gt;</description>
    </item>
    <item>
      <title>类型萃取技术：函数签名当模板参数</title>
      <link>https://microcai.org/2024/11/01/function-signature-as-template-parameter.html</link>
      <pubDate>Fri, 01 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/01/function-signature-as-template-parameter.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/11/01/type-erasuer.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我提到了 std::function 的模板参数，是一个叫&lt;strong&gt;函数签名&lt;/strong&gt; 的东西。&lt;/p&gt;
&lt;p&gt;什么是函数签名？&lt;/p&gt;
&lt;p&gt;比如 main 函数，他的签名是 &lt;code&gt;int(int, char**)&lt;/code&gt;。所谓函数签名，是指函数声明去掉 函数名和变量名 后得到的一个精简描述。 这个精简描述，指导编译器如何按”调用约定“产生具体的汇编指令以调用一个函数。&lt;/p&gt;
&lt;p&gt;函数名，不过是在最后的 call 指令里，提供了具体的目标地址。&lt;/p&gt;
&lt;p&gt;但是，如果你问 decltype(&amp;amp;main) 的类型是啥，其实他的类型是&lt;code&gt;int (*)(int, char**)&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;因为 &amp;amp;main 是 main 函数的函数指针。 函数签名是形如 R(args&amp;hellip;) 的东西，而函数指针的类型，就是 R (*)(args&amp;hellip;)&lt;/p&gt;
&lt;p&gt;函数签名甚至不是一个合法的类型，你不能定义  &lt;code&gt;int(int,int) p;&lt;/code&gt; 这样的一个变量。
但是你可以用 &lt;code&gt;int (*p)(int, int)&lt;/code&gt; 定一个 函数指针 p, 其指向的函数，具有 &lt;code&gt;int(int, int)&lt;/code&gt; 这样的签名。&lt;/p&gt;
&lt;p&gt;那么，对于  std::function 来说，他的模板参数要怎么写，才能接受一个签名呢？&lt;/p&gt;
&lt;p&gt;其实很简单，就把签名当成一个类型。也就是&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Signature&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;function&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么有人问了，这 Signature 就一个类型啊，那 function 的 括号操作符 要怎么写？&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Signature operator()(Signature)&lt;/code&gt; ?&lt;/p&gt;
&lt;p&gt;显然不对。&lt;/p&gt;
&lt;p&gt;这括号操作符，必然是要把签名里的 返回值和参数给拆开来。&lt;/p&gt;
&lt;p&gt;把一个类型里的具体组成部分拆出来？&lt;/p&gt;
&lt;p&gt;哈哈！ 这技术，听起来不可思议！&lt;/p&gt;</description>
    </item>
    <item>
      <title>重提类型擦除器</title>
      <link>https://microcai.org/2024/11/01/type-erasuer.html</link>
      <pubDate>Fri, 01 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/01/type-erasuer.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;十年前，我曾经写过一篇有关类型擦除器的文章, &lt;a href=&#34;https://microcai.org/2014/04/21/type-erasure.html&#34;&gt;见这&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;十年后，我打算再探讨下类型擦除器。&lt;/p&gt;
&lt;p&gt;C++ 对 多态 的支持，在核心层面，就两条： 虚继承 和 模板。&lt;/p&gt;
&lt;p&gt;假设你要设计一个 线程池。这个池你可以“投递”各种任务进去。&lt;/p&gt;
&lt;p&gt;什么叫”任务“呢？ 就是一段代码。于是，早期你想到，可以使用 函数指针。&lt;/p&gt;
&lt;p&gt;于是你的 线程池长这样&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;threadpool&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;void&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;task_function_t)();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;list&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;task_function_t&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; tasks;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; post(task_function_t job);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这样的代码，有个问题，那就是你“投递” 的任务，他干活得有数据。如果投递的任务，只能是一个函数指针。
那么这个函数，就得使用“全局变量“来传递工作内容了。&lt;/p&gt;
&lt;p&gt;所以说，这个 task ，不能是个函数指针。它得携带对象。&lt;/p&gt;
&lt;p&gt;于是，自然的，你想到了 多态，虚函数。那么很快你就改进了第二个版本&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;task&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;virtual&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; run() &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;virtual&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;~&lt;/span&gt;task(){}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;threadpool&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;list&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;task&lt;span style=&#34;color:#f92672&#34;&gt;*&amp;gt;&lt;/span&gt; tasks;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; post(task&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; job);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;显然，如果要给任务携带点状态，就可以写一个 task 对象，比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-cpp&#34; data-lang=&#34;cpp&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;some_task&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; task
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; work_arg1;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; work_arg2;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	some_task(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;run&lt;/span&gt;() &lt;span style=&#34;color:#66d9ef&#34;&gt;override&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#75715e&#34;&gt;// do some work with args.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;想要带上啥状态，一股脑的给添加到自己写的派生类里就行了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>不需要void*user_data的闭包封装</title>
      <link>https://microcai.org/2024/10/31/c-closure-without-void-userdata.html</link>
      <pubDate>Thu, 31 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/31/c-closure-without-void-userdata.html</guid>
      <description>&lt;p&gt;一般来说，如果 C api 接受一个回调，通常会额外允许设置一个 void* 的回调参数。
用户可以把一些额外的参数用这个 void* 传给回调函数。
比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;void&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;read_function_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; read_buf, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; read_size, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_read_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;read_function_t&lt;/span&gt; on_read_function, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这样，用户在回调函数里，就可以使用 user_data 这个参数，获取额外的状态信息。&lt;/p&gt;
&lt;p&gt;但是，也有一些古早时代的 C api, 没有办法设置 user_data。 比如：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;void&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;read_callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; read_buf, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; read_size);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;set_read_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;read_callback_t&lt;/span&gt; on_read);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么回调函数里，就只能拿到库作者设定好的回调信息了。 自己也没有办法传递别的信息给回调处理函数。&lt;/p&gt;
&lt;p&gt;这，必然是库作者的无能，缺陷。是必须要改进的。&lt;/p&gt;
&lt;p&gt;但是，没办法，如果你不得不使用这样的一个无能库，咋办呢？有什么办法传  user_data 进去呢？&lt;/p&gt;
&lt;p&gt;比如，有没有办法实现这样的一个包装器，对上面的 API ，可以做到这样封装&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; read_cb &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; lamba_to_c([&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;捕获其他状态&lt;/span&gt;](&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; read_buf, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; read_size)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{  &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;。。。&lt;/span&gt; &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;处理代码，可以访问&lt;/span&gt; &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;捕获的变量&lt;/span&gt; });
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;//正常来说， 带捕获的 lambda 是没法 cast 成一个 C 指针的。。。 但是有了这个 魔法，它就可以了。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;set_read_callback(&lt;span style=&#34;color:#66d9ef&#34;&gt;static_cast&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;read_callback_t&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;(read_cb));
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;似乎这样的封装对付烂 C API非常给力。只是看起来并不容易实现。&lt;/p&gt;
&lt;p&gt;对 lambda 来说，它本质上是个函数对象。也就是重载了 operator() 的一个匿名类。所以，只要想办法给这个类的 this 找到传递的方式，这个包装器就能实现。
如果 C 库本来就支持 &lt;code&gt;void* user_data&lt;/code&gt; ，那么这样的一个包装器显然并不难写。问题在于，如果 C 库不支持 user_data 参数呢？&lt;/p&gt;</description>
    </item>
    <item>
      <title>微软不会起名</title>
      <link>https://microcai.org/2024/10/30/ms-went-wrong-on-coroutine-naming.html</link>
      <pubDate>Wed, 30 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/30/ms-went-wrong-on-coroutine-naming.html</guid>
      <description>&lt;p&gt;微软不会起名，而且名字还具有极大的误导性。&lt;/p&gt;
&lt;p&gt;先说类名：&lt;/p&gt;
&lt;p&gt;首先，微软的协程原作者，他总是用 &lt;code&gt;Task&amp;lt;&amp;gt;&lt;/code&gt; 来命名一个协程函数。但是这就是他犯的第一个错误。
因为只有 await 构成的一系列调用，那条调用链才是一个 “任务”。 也就是 asio 作者所说的 co_spawn. 只有被 spawn 出来的协程，才叫一个任务。而被 await 的函数，不能叫任务，而是”可异步等待返回的函数“。 因此 asio 作者使用 &lt;code&gt;asio::awaitable&amp;lt;&amp;gt;&lt;/code&gt; 来命名，而不是 &lt;code&gt;task&amp;lt;&amp;gt;&lt;/code&gt; 是十分妥帖的。&lt;/p&gt;
&lt;p&gt;接着是 promise_type ，这个微软就是纯粹的瞎搞了。不同于 Task&amp;lt;&amp;gt; 只是出现在微软的示例代码里，promise_type 可是直接进了标准。这瞎命名带来的恶劣影响要大的多。为啥说这个不能是 promise_type 呢？ 因为这个对象存储的是 协程状态。因此 asio 使用 coro_frame 来命名，显然要更正确的。它存储的就是当前协程帧的状态数据。&lt;/p&gt;
&lt;p&gt;最后是 final_suspend ，这个类名简直就是严重误导性的集大成者。他干的活和 suspend 毫无关系。实际上他干的恰恰不是 suspend 的活，而是 “恢复调用者” 。协程作为可等待函数，他的调用者调用了一个协程后，调用者才是真正的被 suspend 了。被调用者是执行中。处于 running 状态。当被调用者完成工作，他要 恢复 调用者，让调用者醒来继续干活。&lt;/p&gt;
&lt;p&gt;因此， final_suspend 其实应该叫 resume_caller .&lt;/p&gt;
&lt;p&gt;接着说 三件套函数名：&lt;/p&gt;
&lt;p&gt;await_suspend 其实不是 挂起。协程 A 调用 协程 B, 实际上是 A 被挂起。可是代码上却是 调用 B 的 await_suspend 。这简直就是极大的误导性。当 B 对象的 await_suspend 被调用的时候，实际上恰恰是 B 被 “恢复”， B 进入了 running 状态。这个地方准确的命名，应该叫 await_setup.&lt;/p&gt;</description>
    </item>
    <item>
      <title>西方饮食的超高热量</title>
      <link>https://microcai.org/2024/10/27/us-food-has-too-much-cal.html</link>
      <pubDate>Sun, 27 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/27/us-food-has-too-much-cal.html</guid>
      <description>&lt;p&gt;西洋人做食物，最喜欢放的一种调料，叫“黄油”。没有黄油洋人就活不下去。&lt;/p&gt;
&lt;p&gt;洋人对黄油的喜爱到了何种地步？ 制作面包的时候， 是 面粉+白糖+黄油 1：1：1 混合。烤熟后的面包，吃之前要抹黄油。&lt;/p&gt;
&lt;p&gt;偏偏黄油（butter）在英语里，不带油字。做出来的面包，也没有油腻腻的视觉观感。&lt;/p&gt;
&lt;p&gt;于是乎，洋人就会说，中国人吃的炒菜放超级多的油，不健康。他们吃的面包就很健康。&lt;/p&gt;
&lt;p&gt;其实西洋面包，里面的油，比肉包子还多。&lt;/p&gt;
&lt;p&gt;而中国人做馒头，原料居然只是面粉和水，即不加糖，也不加黄油。&lt;/p&gt;
&lt;p&gt;西洋人的食物，有一种魔法，就是把油变成看不见的东西，然后完全吃进肚子里。绝不会遗留在餐盘里让不良商人拿去提炼地沟油。&lt;/p&gt;
&lt;p&gt;又拿吃鸡蛋来说。中国人吃荷包蛋，需要把蛋放油上面煎。煎完的荷包蛋，表面一层油。
洋人吃蛋，会把蛋+油+糖混合，然后打发。变成了一种叫“蛋黄酱”的东西。而且蛋黄酱里超过6层是油。&lt;/p&gt;
&lt;p&gt;不过在英语里，蛋黄酱里即没有蛋黄，也没有酱。所以总是去超市买成品的人，可能还不知道蛋黄酱=鸡蛋+糖+油。它们只知道蛋黄酱很好吃。吃啥都要抹上蛋黄酱。&lt;/p&gt;
&lt;p&gt;西洋人总是说，要多吃菜。于是它们成功的，人均吃菜量相当于中国人的 1/3。
为啥它们菜吃那么少呢？ 原来是为了追求营养价值，它们生吃蔬菜。还污蔑中国人炒菜不健康。&lt;/p&gt;
&lt;p&gt;但是生吃岂是那么好吃的。&lt;/p&gt;
&lt;p&gt;于是它们就要在生吃蔬菜的时候，加配料。也就是沙拉酱。不然完全吃不下。&lt;/p&gt;
&lt;p&gt;那么沙拉酱是啥呢？&lt;/p&gt;
&lt;p&gt;沙拉酱其实就是 糖+油 然后用高速旋转的搅拌机给打发了。&lt;/p&gt;
&lt;p&gt;刚刚还说中国人吃的炒菜表面浮着油，转头自己把油加糖当调料混着生菜给吃了。而且餐盘里还没一滴油剩下。地沟油提炼商都要骂一句抠唆。&lt;/p&gt;
&lt;p&gt;但是有一说一，糖+油打发后，看起来确实不像油。而且名字里也没带油（不管是洋文还是汉文里，都没油）。 于是 糖+油 抹 在菜叶上，这样的食物。。。 看起来就是健康食品啦。&lt;/p&gt;
&lt;p&gt;这就是为啥很多人，只吃西方人推崇的“健康食品”，最后还是吃成了个大胖子。
因为西方人的食品，他就没有健康的。里面全都是油和糖。而且还特意隐藏起来，让你看不到。&lt;/p&gt;</description>
    </item>
    <item>
      <title>从模板的模板论程序员的美学</title>
      <link>https://microcai.org/2024/10/19/template-template.html</link>
      <pubDate>Sat, 19 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/19/template-template.html</guid>
      <description>&lt;p&gt;在编写 &lt;a href=&#34;https://github.com/avplayer/ucoro&#34;&gt;µcoro&lt;/a&gt; 的时候，曾经对一个模板类的成员函数犯难了。那就是等待器三件套之一的 await_suspend 函数。&lt;/p&gt;
&lt;p&gt;我为&lt;code&gt;template&amp;lt;typename T&amp;gt; class awaitable&lt;/code&gt; 的三件套使用这样一个模板签名&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;其中，这个 PromiseType 必须得是 &lt;code&gt;awaitable&amp;lt;T&amp;gt;::promise_type&lt;/code&gt; (也就是 &lt;code&gt;awaitable_promise&amp;lt;T&amp;gt;&lt;/code&gt; ) 的其中一个实例。&lt;/p&gt;
&lt;p&gt;按前C++ 时代的做法，这个成员函数应该这么写&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;awaitable_promise&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这种写法，可以保证接收到的 h 参数，其 Promise 类型必然是 awaitable_promise 的一个参数化实例。&lt;/p&gt;
&lt;p&gt;但是，与此同时，我还希望要为 std::coroutine_handle&lt;void&gt; 这样的通用参数写一个单独的处理代码。&lt;/p&gt;
&lt;p&gt;于是，使用按前C++ 时代的做法，我需要写2个 await_suspend， 他们分别是&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;awaitable_promise&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;await_suspend&lt;/span&gt;(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;对这两个类型的 promise handle, 各自有一套不同的处理代码。&lt;/p&gt;
&lt;p&gt;但是，老王提出了不同意见。他认为，std::coroutine_handle 在标准库里，就一种表示方式，那就是&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;std&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;他批评我说，&lt;code&gt;std::coroutine_handle&amp;lt;awaitable_promise&amp;lt;Any&amp;gt;&amp;gt;&lt;/code&gt; 这样的写法不直观。而且还写了两个 await_suspend
到底哪个在干活，得多费脑细胞。&lt;/p&gt;
&lt;p&gt;后来，函数签名恢复成了&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;但是，使用了 enable_if 之类的模板技巧，外加在 awaitable_promise 里添加一些辅助佐料，实现了&lt;/p&gt;</description>
    </item>
    <item>
      <title>老王语录</title>
      <link>https://microcai.org/2024/10/07/sainta-quotes.html</link>
      <pubDate>Mon, 07 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/07/sainta-quotes.html</guid>
      <description>&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;苹果手机目前在国内主要就是果粉和小姐在用。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;国人大部分开源的项目压根就没有什么洋人感兴趣，不过就是一厢情愿的跪舔洋人而已。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;这些觉的自己母语低一等的人啊，往往又经常在简中社区求关注。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;8k没意义？那些保守党早在1080p时就说过同样的话，不需要4k，如果不是科技推着他们走，他们什么都不需要，电脑也是多余的，他们会说，有人脑干嘛要有电脑？&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;学做人不好吗？偏偏学狼。狼这种畜生都快灭的差不多了吧，有几个人见过真狼的，要学畜生也不能学一个快灭绝了的物种啊。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;用不用新标准，看对自己的定位。如果你是一名合格的c++程序员，你就应该使用。
如果你只是一名c with class的伪c++程序员，你会找一万个理由不使用新标准。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;rust是编程界宗教中的最可怕的一支，到处传教，真是恶心死人了，编程语言千千万万，从来没有让我这么讨厌的一门语言，而且并不是因为rust语言本身有多讨厌，而是这些传教的，让人恶心！！！&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;酒桌文化其实就是一种奴才文化，像极了奴才讨好主子，每次在酒桌上看到一个个给领导劲酒那个奴才相，恶心极了&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;所以要判断一个人是哪方面的大佬，就看他活跃在哪里，哪里写的东西多，这样判断就好了，如果活跃在github或各种邮件列表的各种项目，自然就是程序大佬，如果主要活跃在社交平台，自然就不是程序大佬而是网红了。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;明明就是技术差，非还要找个理由说老版本稳定，老版本稳定的理由简直秀逗了而不自知。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;异步 io 库的 api 接口设计，不应该设计为 setInterval，而应是 setTimeout，但凡只设计为 setInterval 这种方式的 io 接口，都是十分糟糕的设计。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;设置回调其实不过是简单的赋值，这个没有什么开销，简而言之，如果要担心函数指针赋值的开销了，我宁愿相信是程序设计出了问题。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;10月12日添加&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;现在的老师啊，是洗脑主力军&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;普通人应该把学外语的精力多用在学习科学技术上面&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;中文里的一个语气助词就能解决的问题, 英文中要把单词顺序颠来倒去&amp;hellip;  傻B极了。很多人学了几个英文, 从来不思考, 他们语言这些规则是不是糟糕的, 还沾沾自喜, 这种人更傻B。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;11月27日添加&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;买tsl的基本都是傻b, 你和tsl车主交流,真的很容易感受到他们的愚蠢。所以我们千万不要指望能改变他们, 愚蠢是改不了的。&lt;/li&gt;
&lt;li&gt;界面显示数字按3位一分组，说明设计人员要么没脑子或者懒, 要么就是崇洋媚外, 甚至还不自知, 我觉得后面这种可能性更大。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;暂时就收集这么多，以后再加。&lt;/p&gt;
&lt;p&gt;12 月 5 日添加&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;国内关于网络编程领域，就连陈硕的muduo的send设计有问题都没人能指出来，疯狂膜拜reactor，就这种平均水平之下，冒出来一些装模作样支持p2300的sender/receiver模型的人，真的是很奇葩。&lt;/li&gt;
&lt;li&gt;一些人 asio 都用不利索，又TM的会 p2300 的 sender/receiver 了，张口结构化并发，真的是张口就来。&lt;/li&gt;
&lt;li&gt;学了大硕思想，proactor都给你折腾回reactor&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;2025 年 3月15日添加&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;挺乌的目的，其实都是为了反华，而不是什么人道主义。&lt;/li&gt;
&lt;/ul&gt;</description>
    </item>
    <item>
      <title>µcoro 介绍</title>
      <link>https://microcai.org/2024/10/04/deep-into-cpp20-coroutine.html</link>
      <pubDate>Fri, 04 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/04/deep-into-cpp20-coroutine.html</guid>
      <description>&lt;h1 id=&#34;什么是-µcoro-ucoro-actions-workflow&#34;&gt;什么是 µcoro (ucoro) &lt;a href=&#34;https://github.com/avplayer/ucoro/actions&#34;&gt;&lt;img alt=&#34;actions workflow&#34; loading=&#34;lazy&#34; src=&#34;https://github.com/avplayer/ucoro/actions/workflows/ci.yml/badge.svg&#34;&gt;&lt;/a&gt;&lt;/h1&gt;
&lt;p&gt;µcoro 是一个最小化的c++20协程库。精简到不能再删一行代码。&lt;/p&gt;
&lt;h2 id=&#34;什么是-c20协程&#34;&gt;什么是 c++20协程&lt;/h2&gt;
&lt;p&gt;要理解 c++20 协程，首先要理解 无栈协程。 要理解无栈协程，首先要理解“调用链”。&lt;/p&gt;
&lt;h3 id=&#34;调用链&#34;&gt;调用链&lt;/h3&gt;
&lt;p&gt;函数，是被“调用”的。函数 A 调用 函数 B, 函数 B 再调用 函数 C。意思就是当 C 执行完工作，它返回就会回到 B 函数里调用C的那个地方。然后继续执行。
B 函数返回的时候， 它会返回 A 函数里调用B的那个地方。&lt;/p&gt;
&lt;p&gt;这种链试的返回控制流，就是调用链。&lt;/p&gt;
&lt;p&gt;在线程里，调用链是存储在栈上的。在函数返回的地方，编译器生成 ret 指令。而 ret 指令的执行步骤，就是从栈指针获取返回的目标地址。然后将栈指针退行并跳转到目标地址。
现代的调试器，都能在暂停代码执行的时候，检查栈内存，从而获取调用链。&lt;/p&gt;
&lt;p&gt;而有栈协程，就是指多个 “栈” 共享一个内核调度单元——线程。多个协程之间进行切换，实质上就是直接切换了 栈。而切换栈，是一个主动操作，而不是像线程那样由内核抢占式调度。
所以协程又被成为协作式多任务。&lt;/p&gt;
&lt;p&gt;在无栈协程里， 调用链并不存储于栈上。当 协程函数C 完成任务要返回 B, 控制流程会在另外的地方找到它的调用者B,然后跳转到B继续执行。
如果使用调试器，那么调试器按传统的方式找调用栈，在函数C里下断点，也看不到B和A的调用帧。 函数C，函数B，函数A在调试器里看，永远都是由一种复杂的“协程调度器”代码调用的。
如果非要调试 C 返回B 的过程，会发现 C 的代码会先返回到内部的某种“协程调度器“然后紧接着进入 函数B. 而且 B 函数明明是被框架调用的，但是并不会从头执行，而是在上次挂起的地方继续。所谓上次刮起的地方，实际上这个地方就是安排了对C的调用。&lt;/p&gt;
&lt;p&gt;最简单的实现一个 无栈协程 的方式，就是写闭包。在闭包里存储上次挂起的位置。下次执行函数的时候，就从挂起位置继续。可以使用状态机很容易就实现。&lt;/p&gt;
&lt;p&gt;只不过，用手写状态机实现的闭包模拟的无栈协程，任务代码本身就会被为了实现状态机而添加的代码打乱。因此微软为编译器添加了自动化实现可重入状态机的功能，这个机制，就是 c++20协程啦。&lt;/p&gt;
&lt;p&gt;so, c++20协程，是无栈协程的一种。&lt;/p&gt;</description>
    </item>
    <item>
      <title>猪油有利于减肥</title>
      <link>https://microcai.org/2024/09/30/lard-is-good-for-health.html</link>
      <pubDate>Mon, 30 Sep 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/09/30/lard-is-good-for-health.html</guid>
      <description>&lt;h1 id=&#34;为啥会肥胖&#34;&gt;为啥会肥胖&lt;/h1&gt;
&lt;p&gt;要减肥，首先要理解，人为什么会变肥。&lt;/p&gt;
&lt;p&gt;人要活着就要消耗能量。而人体的能量来源，主要靠葡萄糖。&lt;/p&gt;
&lt;p&gt;人体有两大储能系统： 血液和脂肪。&lt;/p&gt;
&lt;p&gt;血液里含有葡萄糖，这是直接储蓄，类比为“活期存款”。血糖会随着代谢的进行被源源不断的消耗，同时也会随着消化的进行，源源不断的被补充进来。&lt;/p&gt;
&lt;p&gt;如果血糖的浓度偏离了一个正常值，就会激发人体的代偿机制： 将多余的葡萄糖转换为脂肪或者反过来，将多余的脂肪转换为葡萄糖。&lt;/p&gt;
&lt;p&gt;而人发胖，机制就是因为经常性的触发“葡萄糖转换为脂肪”的储能机制。&lt;/p&gt;
&lt;h1 id=&#34;为啥总是储能而不释放&#34;&gt;为啥总是储能而不释放&lt;/h1&gt;
&lt;p&gt;简单的来说，就是吃多了。&lt;/p&gt;
&lt;p&gt;人吃入的能量，大于自身活动消耗的能量，长年累月下来，可不就“储蓄”起来了。&lt;/p&gt;
&lt;p&gt;由于人类并没有直接排泄储蓄的生理机制。因此要减肥，只有一种办法：长期食物摄入不足。如果不想减少食物摄入，可以通过增加运动消耗来变相实现食物摄入不足。&lt;/p&gt;
&lt;h1 id=&#34;节食为何困难&#34;&gt;节食为何困难&lt;/h1&gt;
&lt;p&gt;增加运动，确实可以抵消吃的多。但是经常运动减肥的人会明白，运动后会吃的更多。于是食物摄入的能量仍然超过了消耗。&lt;/p&gt;
&lt;p&gt;这是为何呢？&lt;/p&gt;
&lt;h1 id=&#34;人体靠什么控制食物摄入&#34;&gt;人体靠什么控制食物摄入&lt;/h1&gt;
&lt;p&gt;人，口渴了就会喝水。饿了就要吃东西。身体会明明白白的通过自身感受来激发大脑的主观能动性，以实现内部的平衡。
所有肥胖的人，都有一个共同特点：易饿。正如所有尿结石的人，也有一个共同特点：不容易口渴。&lt;/p&gt;
&lt;p&gt;饿了，身体就在鞭策大脑，赶紧寻找食物。肥胖的人无法靠运动减肥，正是因为运动后，身体会变得更渴望食物。&lt;/p&gt;
&lt;p&gt;因此，减肥，就是要锻炼自己的意志力，和身体的饥饿信号做斗争。&lt;/p&gt;
&lt;h1 id=&#34;对抗饥饿感&#34;&gt;对抗饥饿感&lt;/h1&gt;
&lt;p&gt;如果人的意志力无比强大，那么吃什么东西，自然只要拿着电子称+热量表。算好每日能量摄入量即可完成减肥。&lt;/p&gt;
&lt;p&gt;但是，这何其的难！&lt;/p&gt;
&lt;p&gt;事实上，有一种更简单的办法，就是创造“饱腹感”。&lt;/p&gt;
&lt;h1 id=&#34;高热量食物并不真的高热&#34;&gt;高热量食物并不真的高热&lt;/h1&gt;
&lt;p&gt;高热食物，是指食物的能量密度高。吃同样体积的食物，高热食物的能量更多。因为人每顿吃的食物是固定体积的。“填”饱肚子就算吃好了。
因此如果吃高热食物，则相比吃低热量食物，会摄入更多的能量。&lt;/p&gt;
&lt;p&gt;然而事实果真如此吗？&lt;/p&gt;
&lt;h1 id=&#34;食物的饱腹感&#34;&gt;食物的饱腹感&lt;/h1&gt;
&lt;p&gt;人的身体发出“吃饱”了的信号，并不完全靠胃容积信号。一些食物，哪怕吃的体积并不大，也会让身体发出“吃饱了”的信号。
这类食物，就是所谓的拥有较高饱腹感的食物。&lt;/p&gt;
&lt;p&gt;因此，哪怕是高热食物，只要它拥有较高的饱腹感，人一样会主动的减少摄入量。使得总的能量摄入，并不比吃低热量食物更多。&lt;/p&gt;
&lt;h1 id=&#34;被误解的猪油&#34;&gt;被误解的猪油&lt;/h1&gt;
&lt;p&gt;我小时候，几乎每家每户都有熬猪油的习惯，家里厨房常备一个罐头瓶子，里面都是凝固的白色猪油，妈妈无论是炒饭，还是煮面条，还有炒青菜都会用猪油，那中温暖滋润的感觉，一辈子都难忘。
可是不知道从什么时候起，白色的猪油瓶子渐渐消失了，很少有人会专门熬猪油，大多数人对猪油更是避之而不及。
大概是从生活条件变好了，植物油的产量也丰盛了，胖子越来越多了，患心脑血管疾病的人越来越多了。直到现在猪油还是被主流的健康媒体认为是不健康的食物，欲除之而后快。&lt;/p&gt;
&lt;p&gt;那些媒体为什么说猪油不健康？主要是说的饱和脂肪含量高、胆固醇和卡路里高，容易让人胖，容易堵塞血管。人们根据以形补形的直观理解，也很容易接受这个观念。&lt;/p&gt;
&lt;p&gt;简单的来说，猪油是一种高热量食物。&lt;/p&gt;
&lt;h1 id=&#34;猪油能提供饱腹感&#34;&gt;猪油能提供饱腹感&lt;/h1&gt;
&lt;p&gt;如果一顿饭里摄入一勺猪油和一勺植物油相比较，前者的满足感明显更强，饱腹感维持的时间也更强。
可见猪油虽然是高热量食物，但是猪油能提供更大的饱腹感。也就是说，使用猪油炒菜，人每顿饭会吃的更少。&lt;/p&gt;
&lt;p&gt;很多人减肥失败，甚至走上暴食的道路，都是由于长期吃饭不满足、不幸福、还饿得快。因为植物油无法提供饱腹感。于是为了追求吃的饱，会下意识的吃的更多。&lt;/p&gt;
&lt;p&gt;低热量的食物，吃多了，总能量也是比 吃少量高热量食物 更多。&lt;/p&gt;
&lt;p&gt;猪油能提供更强的饱腹感，意味着猪油是一种天然的“节食药”。&lt;/p&gt;
&lt;h1 id=&#34;吃猪油能减肥&#34;&gt;吃猪油能减肥&lt;/h1&gt;
&lt;p&gt;因此，我的结论就是，吃猪油的人，会比吃植物油的人，每日摄入更少的食物。虽然食物单位质量所含的能量比使用植物油烹饪出来的多，但是少吃几口饭就把猪油里多含的能量抵消回去了。
而且肚子里有猪油，人会更耐饿。常吃植物油的人，哪怕顿顿都摄入了充足的能量，身体还是会不断的向大脑发出“我饿了，我饿了”的信号。于是忍不住的会吃上一些零食。&lt;/p&gt;
&lt;p&gt;所以，为了健康，还是不要听金龙鱼忽悠吃什么劳什子大豆油吧。&lt;/p&gt;</description>
    </item>
    <item>
      <title>同居是没有保障的婚姻</title>
      <link>https://microcai.org/2024/09/12/girls-are-stupid.html</link>
      <pubDate>Thu, 12 Sep 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/09/12/girls-are-stupid.html</guid>
      <description>&lt;p&gt;现代女性恐惧婚姻，却不恐惧同居。反而欣欣向荣。&lt;/p&gt;
&lt;p&gt;然而，同居就是没有保障的婚姻。女人对法律给予的保障十分的恐惧，反而喜欢裸奔。
为啥同居就是没有保障的婚姻呢？&lt;/p&gt;
&lt;p&gt;因为现行的婚姻法，对女性的约束力几乎没有，写满了对男性的约束力。对男人来说，结婚的性价比太低，不如同居划算。因为结婚了，也不能约束伴侣。反而自己被法律给管辖起来了。
倒不如只同居，不结婚。这样双方都是裸奔，都没有法律保护。那就看谁在法律外的力量大了。&lt;/p&gt;
&lt;p&gt;看明白过来的女人，开始热衷相亲。而想透的男人，不结婚了。
于是产生了千人相亲大会没有男人去的奇观。&lt;/p&gt;
&lt;p&gt;只不过，还有很多女人没想明白，热衷于同居被白嫖。男朋友提结婚她还急。
而，男人嘛，一样一堆没想明白的，热衷于结婚。还要花天价彩礼。明明俩人已经同居了，既然能白嫖，为啥还要掏天价彩礼？&lt;/p&gt;</description>
    </item>
    <item>
      <title>航天应用下参考系的选取</title>
      <link>https://microcai.org/2024/07/01/what-reference-frame-to-use.html</link>
      <pubDate>Mon, 01 Jul 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/07/01/what-reference-frame-to-use.html</guid>
      <description>&lt;p&gt;这俩月，航天的话题比较热。吸引了我的全部注意力。&lt;/p&gt;
&lt;p&gt;只是跟着热点跑，那我也就不是我了。&lt;/p&gt;
&lt;p&gt;以前高中学习万有引力的时候，从未考虑过的事情，突然变得烦恼起来。那就是，在航天领域，用的是什么坐标系？&lt;/p&gt;
&lt;p&gt;火箭要送卫星上天，必须要靠导航。导航导航，导引航迹。必须得知道自己在哪。
知道自己在哪，就必须得描述出来。&lt;/p&gt;
&lt;p&gt;在地面上，位置可以用 经纬度+高度 表达。在地面运动的物体，也直接拿地面当惯性参考系。
但是，在天上，总不能拿那个“旋转”的地面当惯性参考系吧？ 应该直接以地心作为坐标原点的三维坐标系，而抛弃经纬度。问题在与，如何确定这个坐标系的轴的方向。&lt;/p&gt;
&lt;p&gt;第一宇宙速度，为 7.9km/s，是以谁为参考的？&lt;/p&gt;
&lt;p&gt;以地心？ 那么问题来了，环绕地球做圆周运动，必须得有第三方参照物。没有第三方参考，2体互绕运动是不成立的。
如何选取这“第三方”参照物呢？&lt;/p&gt;
&lt;p&gt;太阳是一个可选项吗？&lt;/p&gt;
&lt;p&gt;如果太阳是固定的，那么必然可以观测到，卫星在绕地球转。可是，如何确定地球在绕太阳转呢？&lt;/p&gt;
&lt;p&gt;“遥远的恒星” 似乎可以作为一个背景，证明地球在绕太阳转。所以太阳不能作为地心参考系的轴方向参考。&lt;/p&gt;
&lt;p&gt;但是，如果我们要进行导航，就必须建立一个绝对的基准点。“遥远的恒星”这个表述，显然并不能获得认可。在工程实践上也无法使用。&lt;/p&gt;
&lt;p&gt;就在我百思不得其解的时候，突然想到了陀螺仪。&lt;/p&gt;
&lt;p&gt;那么，就可以使用地球的球心作为坐标系原点，以“陀螺仪”的指向为坐标系的轴。如此，卫星和地球，就有了一个绝对的“圆周”运动。&lt;/p&gt;
&lt;p&gt;但是，等等，陀螺仪的指向，就真的是绝对的吗？&lt;/p&gt;
&lt;p&gt;如果陀螺仪的指向是绝对的，那是不是2体互绕运动就有了一个“绝对”的参考系？&lt;/p&gt;
&lt;p&gt;这不符合马赫原理。&lt;/p&gt;
&lt;p&gt;迄今为止，人类真正能说，找到了宇宙绝对不会有错的定理，就是热力学定理和马赫原理。狭义相对论因为无法和马赫原理兼容而抛弃。
而广义相对论，也不完全兼容马赫原理。这正是广义相对论不完善的地方，也是它无法和量子力学统一的根本所在。&lt;/p&gt;</description>
    </item>
    <item>
      <title>中国古人的天地宇宙观</title>
      <link>https://microcai.org/2024/05/27/ancient-chinese-knew-earch-is-a-sphere.html</link>
      <pubDate>Mon, 27 May 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/05/27/ancient-chinese-knew-earch-is-a-sphere.html</guid>
      <description>&lt;p&gt;在学习世界历史的时候，我知道麦哲伦16世纪完成了环球航行。于是证明了地球是个球。地圆说终于获得实捶证据。从此天圆地方再无市场。&lt;/p&gt;
&lt;p&gt;但是，麦哲伦那个时代，一定是对于大地到底是平的还是圆球的，争论不休。也就是说，有相当的一部分人认为，大地是个球。只不过没有实际的证据。&lt;/p&gt;
&lt;p&gt;那，这些早就认为大地是球的人，他们的认知来自何方？ 这种明显偏离日常经验的知识，必然是源自经年累月的思考和观察。&lt;/p&gt;
&lt;p&gt;而且，这样的“争论”应该是已经旷日持久。只有在旷日持久的争论下，可能还是“世纪争论”下，麦哲伦才能向国王申请到“项目经费”，为这场世纪争论盖棺定论。&lt;/p&gt;
&lt;p&gt;既然争论由来已久，那么“地圆说”的支持者，必然是有所传承的。“地圆说”必须得有个开端，不那么准确的猜想开始。然后经历数代人的完善修正，最终提出完整的地圆说。&lt;/p&gt;
&lt;p&gt;不可能是某个天降神人，某日突发奇想，然后就能“说服”一大帮的信徒。&lt;/p&gt;
&lt;p&gt;可惜，我在西方历史上，没找到这样的演化发展痕迹。地圆说在西方好像是突然出现——或者说，突然的挖到了千年前埋藏的某个古希腊著作——然后突然大家争论。然后突然来个冒险家弄了个实锤证据。
西方的很多科学技术，都有突然性。突然就发现了某本古希腊的典籍。这些典籍，千年以来无人问津，突然就天下闻名了。&lt;/p&gt;
&lt;p&gt;像极了中国远古时候。比如 天降神农氏发明药学。天降黄帝发明医学。天降仓颉发明了文字。天降有遂氏发明了火。。。。&lt;/p&gt;
&lt;p&gt;除了上古时代，其他时候倒是各种发明都是有迹可循。慢慢的发展而来。发明不再是某个天降神人，而是很多代人的接力棒。&lt;/p&gt;
&lt;p&gt;不过，中国上古时期的“天降神人”，是因为近古时期的人已经忘记了某种东西具体是如何发明出来的。因此嫁接了一个神人。嫁接的时候，他们用这些东西其实已经很久很久了。久到忘记了“祖师爷”到底是谁。&lt;/p&gt;
&lt;p&gt;西方不一样，天降神人的东西，他们是真的才知道。不是 时代久远导致习以为常使用的东西都不知道是谁发明的。&lt;/p&gt;
&lt;p&gt;好像西方在近代，是突然顿悟了某项科技，而这个科技恰好可以到古希腊里找到出处。而且这个神人必须天赋异禀，在同期的人还在茹毛饮血的时候就已经完成了千年思索。&lt;/p&gt;
&lt;p&gt;后来仔细研究，才发现，地圆说，其实早在汉代张衡就已经很明确的指出了。&lt;/p&gt;
&lt;p&gt;张衡在他的浑天说代表作《浑天仪图注》里说:“浑天如鸡子.天体圆如弹丸,地如鸡中黄,孤居于内,天大而地小.天表里有水,天之包地,犹壳之裹黄.天地各乘气而立,载水而浮.周天三百六十五度又四分度之一;又中分之,则一百八十二度八分度之五覆地上,一百八十二度八分度之五绕地下,故二十八宿半见半隐.其两端谓之南北极”。&lt;/p&gt;
&lt;p&gt;而张衡的学说，也不是他个人的独创。也是整理了先秦的研究而成的。&lt;/p&gt;
&lt;p&gt;但是，很明显，浑天仪“失传”了。&lt;/p&gt;
&lt;p&gt;因为，同时期，中国大地上还有盖天说。盖天说就是天是个锅盖，盖在地上。当多个学说竞争的时候，张衡的学说就未必获得大家的重视。作品失传是很自然的。&lt;/p&gt;
&lt;p&gt;也就是说，天是圆的，但是地是平的还是个球，在古代并没有“定论”。张衡说的那些也不过是 “一家之言”。但是百家争鸣嘛，所以各种学说都有。最关键的是，谁的学说更能解释客观现象。&lt;/p&gt;
&lt;p&gt;但是，浑天说没有失传。严格来说，浑天说，就是日后官方主持修订历法所依赖的主流学说。因为只有浑天说，最符合观测。浑天说虽然处于修天文的人的主流，但是没有成为”社会主流“。
根本原因是因为没有提出”万有引力“定律。导致无法解释球的另一面。 因此，他对于古代中国人来说，算是一个有瑕疵的理论。于是只有学习天文的人才会接受这个理论以便更好的观测天象。
而普罗大众则不接受。&lt;/p&gt;
&lt;p&gt;真正让这个理论，从钦天监官员那，普及到普通人，是因为“大航海”。海上的航行，是真的发现地球曲率的。但是，地的另一边的人怎么不掉下去？&lt;/p&gt;
&lt;p&gt;因此，当时信奉浑天说的人，是用这个东西来安慰自己的。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-05-27_04-04-14.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;也就是说，浑天说内部，就分为全球体和半球体两派。&lt;/p&gt;
&lt;p&gt;因为，球的另一半（也就是美洲大陆），没人去过！！&lt;/p&gt;
&lt;p&gt;这就是为何，唐代僧一行主持子午线测量，也不说大地是球。因为他的测量行为，最多证明大地是半球。全球派没有市场。全球派最多是从“哲学”角度思考，半球状的大地，不符合宇宙的美学。but这种想法说服不了众人。既然说服不了众人，就无需说服。他能用这个理论，指导他完成新历法的修订就可以了。&lt;/p&gt;
&lt;p&gt;能真正证明大地是球，除非找到背面的那块大陆，并且通过环球航行证明那个大陆在背面。&lt;/p&gt;
&lt;p&gt;而背面那块大陆，真的找到了！&lt;/p&gt;
&lt;p&gt;当大地确确实实是个球，那么困扰浑天说几千年的问题，就不得不解答了。美洲人为啥不掉下去？&lt;/p&gt;
&lt;p&gt;对这个问题的思考，最终诞生了万有引力定律。&lt;/p&gt;
&lt;p&gt;那么问题来了，麦哲伦为何如此“坚信” 浑天说的大地全球派？ 他的行为，更像是已经从某个“先知”那获得了他自己能完全信服的证据，然后急于向自己的老乡用老乡能懂的语言证明先知是正确的。&lt;/p&gt;
&lt;p&gt;那么只有一种可能：他见过地球仪。&lt;/p&gt;
&lt;p&gt;这种问题，本来是无解的，直到后来，那副 100% 证明地球是个球的《坤舆万国全图》确定绘制于明朝初期。而不是万历年间。&lt;/p&gt;
&lt;p&gt;《坤舆万国全图》被证实是绘制于郑和下西洋时期。于是，利玛窦带来西方的“地圆说”就成了无稽之谈。
顺带的，围绕利玛窦诞生的许多历史，自然全都是伪史了。&lt;/p&gt;
&lt;p&gt;在研究这个历史的时候，我惊讶的发现，儒家的人大部分不支持浑天说。尤其是超级大儒，朱熹。朱熹把浑天说批判为离经叛道。这也就难怪，朱熹的学说在明朝成为儒家唯一正统后，大明的科技日渐败退了。朱熹为何不喜浑天说？&lt;/p&gt;
&lt;p&gt;因为在宋朝，信奉浑天说的人，已经将浑天说演化发展到非常接近现代的宇宙学了，对很多虔诚的儒教徒来说，他们是一群疯子！ 这种宇宙学，对儒家讲的天命观是一种釜底抽薪式的打击！ 这也是为何，朱熹的儒学，是非常的歇斯底里的神经病版的儒学。&lt;/p&gt;
&lt;p&gt;要用疯子对抗疯子。&lt;/p&gt;
&lt;p&gt;大明，随着笃信航海观念的陈友谅的战败，龟缩一地追求安分守己的朱熹派成为天朝正统。并且通过八股取士，海禁，彻底消灭其他异端学说。&lt;/p&gt;
&lt;p&gt;这些异端学说，只能“漂洋过海”，并且在欧洲找到继承人的时候，学习孙悟空的师傅吩咐道，“不许说是我的徒弟”。&lt;/p&gt;
&lt;p&gt;不许说？那就说我师承古希腊人吧。&lt;/p&gt;</description>
    </item>
    <item>
      <title>物业就是现代版的皇权不下乡</title>
      <link>https://microcai.org/2024/05/20/no-gov-in-residential.html</link>
      <pubDate>Mon, 20 May 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/05/20/no-gov-in-residential.html</guid>
      <description>&lt;h1 id=&#34;皇权不下乡&#34;&gt;皇权不下乡&lt;/h1&gt;
&lt;p&gt;在古代，皇权的主要目的就是征税和征兵。而征税是可以“外包”的，征兵后来被“募兵”取代。&lt;/p&gt;
&lt;p&gt;于是，维持到村的基层治理体系就变得毫无意义。所谓皇权不下县，就是在县以下的行政单位基本上靠“士绅”自治。&lt;/p&gt;
&lt;p&gt;其实古代皇权不下县到明清时代才特别明显。秦汉时期，皇权不仅要下县，还要扎根在村里。
因为秦朝的 “耕战” 制度，全民皆兵。每有战争，皇帝就要派人到村里挨家挨户的征兵。&lt;/p&gt;
&lt;p&gt;在工业社会到来前，人口大多数居于村庄。因此要维持军队数量，必然是要深入广大农村地区征兵。&lt;/p&gt;
&lt;p&gt;明清时期，皇权不下县就特别明显了。主要是皇帝的兵，不来自农村。&lt;/p&gt;
&lt;p&gt;明朝前期，兵员主要来自“卫所”的军户。 军户时代为兵。闲时耕作，战时为兵。这一下子就把全国人划分成了两波人： 负责供养军队的人，和负责上战场的人。而且大部分人口被划入供养军队的范畴。&lt;/p&gt;
&lt;p&gt;不过后来随着吏治的腐败，卫所制度逐渐崩溃。于是募兵制替代了卫所制。募兵制下，兵员由将领用钱招募而来。既然是用钱募集而来，自然犯不上到农村里挨家挨户的征兵。&lt;/p&gt;
&lt;p&gt;清朝其实就是改名了的明朝。 所谓的 “八旗”制度，其实就是明朝的卫所制。明朝的军户世代为兵。八旗的旗丁也是世代为兵。&lt;/p&gt;
&lt;p&gt;只不过，朱元璋的卫所追求数量，全国有几百万军户。而清朝走精兵路线，全国只有十几万旗丁。&lt;/p&gt;
&lt;p&gt;同大明类似，大清也发现“世代为兵”的人数量不够，于是也用钱来凑。于是就有了绿营兵。&lt;/p&gt;
&lt;p&gt;因此在明清两朝，划入“普通农户”的全国绝大多数人口，其实是没有兵役的。当兵，是那些“军户/旗人”的义务。
因此，皇帝并不需要建立村一级的行政机构去挨家挨户的征兵。&lt;/p&gt;
&lt;p&gt;至于征税，则可以“外包”。明清时期，老百姓并不直接向官府纳税。而是将税粮交给“代理人”。这些代理人，在秋收时节，就会下乡挨家挨户的搜刮粮食。&lt;/p&gt;
&lt;p&gt;因此，皇帝大手一挥，“免三年税”。其实只是喂饱了那些代理人。&lt;/p&gt;
&lt;h1 id=&#34;政府不进小区&#34;&gt;政府不进小区&lt;/h1&gt;
&lt;p&gt;到 21 世纪，很多时候城里人会发现，自己事实上是被“资本家”统治的。生活上找不到政府的痕迹。可能对一个普通城市居民来说，他实际上是被一种叫
“物业”的资本家治理的。&lt;/p&gt;
&lt;p&gt;这个其实就是现代城市版的皇权不下乡。在古代，县以下的政府是不存在的。由“乡贤”自治。在现代城市，市以下的政府也是不存在的。城市的基层是由 ”物业“ 统治的。
”物业“也是一种”自治“机构。由”乡贤“承担。哦，不，应该叫”城贤“了。&lt;/p&gt;
&lt;p&gt;乡贤可不是谁都能当的。他得有“功名”在身，还得有“名望”。所谓功名，就是参加过科举，最次也得是各秀才。在卷的地方，还非得是举人才行。所谓名望，就是当地世家大族的“认可”。
城贤也不是谁都能当的。他得有“资本”才行。还得有“业主大会的认可”。&lt;/p&gt;
&lt;p&gt;正如古代社会，皇权不下乡是一步一步的。现代城市的皇权不下乡也是一步一步的。&lt;/p&gt;
&lt;p&gt;在建国初期，城里需要 “挨家挨户” 干活的任务，是交给城市真正的基层政府“居委会”干的。正如秦汉时期，需要到村里挨家挨户干活的任务，是交给当时真正的基层政府做的——比如刘邦当的亭长是也。
但是，到了明清时期，皇权不下乡，导致农村的治理靠乡贤自治。
现在，城市的基层，也进入”皇权不下乡“时代，靠”物业“ 这种城贤自治了。&lt;/p&gt;
&lt;p&gt;其实起源都是一样的，现代城市的征税主体不是“住户”，而是“公司”。因此管理住户这种任务就可以“外包”出去了。
哪怕其实公司，也是住在 “产业园”，但是你会发现，天朝政府并不靠 产业园 的物业管理那些公司，而是直接管理。&lt;/p&gt;
&lt;p&gt;因此，只要政府还靠“物业”进行城市基层管理，就不可能征收的了房产税。
必须重建城市基层政府，才能切实管理“住户”从而从住户身上直接征税。&lt;/p&gt;</description>
    </item>
    <item>
      <title>阿波罗载人登月了么</title>
      <link>https://microcai.org/2024/05/17/is-apollo-faked.html</link>
      <pubDate>Fri, 17 May 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/05/17/is-apollo-faked.html</guid>
      <description>&lt;p&gt;第一次知道载人登月这个事情，是在教科书上。因为是教科书上讲的事情，我对阿波罗载人登月这个事情是深信不疑的。&lt;/p&gt;
&lt;p&gt;长大后，随着互联网的普及，开始接触到了老美那边流传的”登月造假“阴谋论。&lt;/p&gt;
&lt;p&gt;当然，第一次听到有人说登月是造假的时候，我第一反应是不信（造假）的。
不过，即使不信，我还是会看看他们的理由。&lt;/p&gt;
&lt;p&gt;当质疑者提出他们的理由的时候，我的第一反应是，他们说的好有道理，但是肯定背后有一些我不知道的科学道理。
果然，反驳质疑者马上就一一给圆回来了。&lt;/p&gt;
&lt;p&gt;我的反应是，原来背后还有这么深刻的科学道理啊！学习了！&lt;/p&gt;
&lt;p&gt;那时候，反驳质疑的人，会耐心的讲解质疑者不理解的现象。&lt;/p&gt;
&lt;p&gt;然后过了很多很多年。&lt;/p&gt;
&lt;p&gt;突然质疑登月造假的舆论又开始甚嚣尘上。我还纳闷了，咋这种话题又火了。仔细一搜，发现原来是中国的探测器登月了。借着东风，又炒了一波。&lt;/p&gt;
&lt;p&gt;但是，这次，反驳质疑的人，不耐心了。全力开启了嘲讽模式，对质疑者阴阳怪气。仿佛美国登月是一种宗教，不容质疑。&lt;/p&gt;
&lt;p&gt;而这次，质疑者不再是因为无知而提出了很多问题，而是搬出了证据。&lt;/p&gt;
&lt;p&gt;我也开始觉得，质疑者不是空穴来风了。看来老美也许真的做了假？&lt;/p&gt;
&lt;p&gt;不过，我觉得既然各执一词，不如静待中国载人登月。倒是很多疑惑能获得更好的解答。何必对质疑者阴阳怪气呢？而反驳着那种高高在上的态度，阴阳怪气的口气，让我很不舒服。
我还是倾向于这种事情与其争吵不如静待。现在信的太过，保不齐将来打脸呢？ 我开始隐隐约约的认为老美造假了。
因为反驳者的行事风格就是典型的”水军霸凌“。正义一方何必雇佣水军呢？&lt;/p&gt;
&lt;p&gt;于是，又安静了好多年。直到最近，登陆造假的话题随着嫦娥六号的登月又双叒叕火起来了。&lt;/p&gt;
&lt;p&gt;这次舆论一边倒的质疑了。和前几年那次反驳者霸凌质疑者的情况完全不同，质疑者各种回旋镖，而反驳的人少了很多。
不过，正如去年 Mate 60 发布一样。水军只是迟到，从来不缺席。&lt;/p&gt;
&lt;p&gt;随着时间的推演，反驳着再次占据上风。质疑者再次被打倒为“智障”，“爱国狗”，“义务教育漏网者”。&lt;/p&gt;
&lt;p&gt;这事情没有幕后推手，才是真的有鬼了。&lt;/p&gt;
&lt;p&gt;我不用去仔细看双方的证词。我只要知道，无组织者在网络上斗不过水军。正如 Mate 60 发布一阵后，水军经费到账后，华为再次被黑残。
凭此矩阵行为，我已经可以断定，阿波罗载人登月一定造假。&lt;/p&gt;</description>
    </item>
    <item>
      <title>现代婚姻制度错在哪？</title>
      <link>https://microcai.org/2024/05/04/in-the-name-of-gender-equality.html</link>
      <pubDate>Sat, 04 May 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/05/04/in-the-name-of-gender-equality.html</guid>
      <description>&lt;p&gt;古代婚姻制度的基础是家族联姻。现代婚姻制度的基础是“人人平等”。&lt;/p&gt;
&lt;p&gt;咋一听，好像进步了。其实不然。准确的说，没有所谓的现代婚姻制度，而是西方的婚姻制度和中国的婚姻制度。大清灭亡后，中国的婚姻制度就没了，被西方婚姻制度取代了。&lt;/p&gt;
&lt;p&gt;西方的婚姻制度的第一要义是“算计”。为啥说是算计呢？ 因为“人人平等”。以人人平等之名行掠夺之实。结婚双方，一直在算计对方。各种西式鸡汤也不断的提醒你，要“计较”婚姻中的得失。免得被算计。&lt;/p&gt;
&lt;p&gt;这种西方的算计式生活数百年来早就融入了西方人的基因。西方人从生下来到死去，没有一秒钟不在“算计”。做生意要算计，工作要算计，买东西要算计，谈恋爱要算计。结婚也要算计。连养孩子都要和孩子算账。&lt;/p&gt;
&lt;p&gt;因此，西方的婚姻制度，是适应西方的人口基因的。&lt;/p&gt;
&lt;p&gt;但是，这样的制度，直接抄到中国来使用，犯了严重的水土不服之病。&lt;/p&gt;
&lt;p&gt;因为西方的女人内裤是很松的。所以西方的婚姻制度，其社会基础，其实是婚前浪如妓，结婚如从良。因此西方的婚姻，更像是妓女从良仪式。彩礼？ 不存在的。能有从良机会就要感动的稀里哗啦的。
西方女人被男人求婚的时候感动到落泪是普遍现象。&lt;/p&gt;
&lt;p&gt;但是在东方，女人要看好裤子的道德观念，并没有随着大清的灭亡而灭亡。女人裤腰带变松，是从改革开放开始的。因此，西方的婚姻制度对中国水土不服的表现其实也是从改革开放以后才显露出来的。而不是从民国引入西方婚姻法开始。&lt;/p&gt;
&lt;p&gt;之所以开始水土不服，是因为女人比男人更快的接纳了西方的算计文化。腰带宽松的妓女，却不按从良的规矩，依旧摆出黄花大闺女的架势要求男性，要三媒六聘，要八抬大轿。
婚后却不守妇道，要以西方“自由平等”的方式对待婚姻。&lt;/p&gt;
&lt;p&gt;于是，不兼容性开始凸显。&lt;/p&gt;
&lt;p&gt;很多男人不知道的一个事实就是，中国一个很普通的家庭主男，在西方社会女人需要十世苦修才能遇上。娶洋妞的家庭，洋妞都是笑开花。而嫁洋屌的女人，除了裤衩满足了，别的说多了都是泪，也不敢说出去。&lt;/p&gt;
&lt;p&gt;洋妞虽然也是西方文化，但是不双标。他用西方文化的标准看待中国老公，自然得出十世好男人的结论。中国女人用双标的眼光看老公，自然是咋看咋不顺眼。&lt;/p&gt;
&lt;p&gt;中国几千年来重男轻女的思想，为何培养出的男人，却是西方人眼中的“十世好男人”？&lt;/p&gt;
&lt;p&gt;因为中国社会，压迫女性的从来就不是婚姻。而是社会。女孩子在社会上多受苦，在家里就要多关爱。而西方社会，女性是在家庭和社会双重压迫下，才生出了平权运动。而且她们的平权运动不敢砍向老公，只能砍向社会。
于是社会上，女性获得了工作的权利。但是所谓的平等，是建立在女性要在生理条件不如男性的情况下强行平等。个中滋味只有女人自己知道。&lt;/p&gt;
&lt;p&gt;而在中国社会，因为女性无法工作。没有独立的经济。因此就必须在婚姻上进行补偿。因此数千年来，中国男人的教育就是要疼老婆。还要把不疼老婆的人写入坏人传。
中国历史上有多少后宫干政的事情？ 没有在宠女人的文化环境下长大的皇子，继位后，只可能把女人当工具。不可能去宠。&lt;/p&gt;
&lt;p&gt;中国男人宠女人，是在女人自身弱小，在社会对女人不公平的情况下产生的。&lt;/p&gt;
&lt;p&gt;结构，改革开放太快了。社会发展太快太快。中国男人的思维还停留在要疼女人的古代观念上。却碰到的尽是精于算计的西方精神的女人。
二者之间的矛盾就无法调节了。&lt;/p&gt;
&lt;p&gt;更要命的是，恪守妇道的传统女人，遇到的尽是精于算计的西方男人。而老实的男人，通常遇不到传统女人。于是整个中国家庭，都是建立在大量的不平等之上。&lt;/p&gt;
&lt;p&gt;这种错配，要一直持续到传统思维下的男人消磨殆尽为止。要知道，西方是不存在捞女的。&lt;/p&gt;
&lt;p&gt;所谓的“婚前财产”设计，只是在目前错误的，不适合国情的婚姻制度下，打了一个小补丁。以此想弥补一下传统的中国男人。
结果利用这个设计的，尽是精于算计的西方男人。被算计的，很多还都是传统思维下的女人。&lt;/p&gt;
&lt;p&gt;到底是要继续动荡到硬着陆，还是承认西方婚姻制度失败，重新探索适合东方家庭的婚姻制度？&lt;/p&gt;</description>
    </item>
    <item>
      <title>沙雕动画 vs 腾讯动画</title>
      <link>https://microcai.org/2024/03/21/shadiao-ani-vs-tencent.html</link>
      <pubDate>Thu, 21 Mar 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/03/21/shadiao-ani-vs-tencent.html</guid>
      <description>&lt;p&gt;很多人说，看国产的动画片，配音不好。然后就跑去看日本片去了。更有奇葩的，要看日语配音的国产动画片。&lt;/p&gt;
&lt;p&gt;其实，cv 不专业并不是主要原因。有人说那叫“母语羞涩”，在我看来也不是主要原因。&lt;/p&gt;
&lt;p&gt;我认为，根本原因是台词出了问题。&lt;/p&gt;
&lt;p&gt;一般人们常把语言分为口语和书面语。
其实，还有一个类型，它既不是口语，也不是书面语，而是专用于台词的语言。&lt;/p&gt;
&lt;p&gt;人物的台词，即不能照搬口语使用，也不能直接使用书面用语。&lt;/p&gt;
&lt;p&gt;最为明显的例子，当属《三国演义》。 三国演义里的台词，既不是原著上的书面语，也不是生活化的口语。它是那种通俗易懂的，一听就懂，但是又不是白话的语言。
让你一听就觉得，古人就应该这么说话。&lt;/p&gt;
&lt;p&gt;其实何止古人。电视剧里的人，都应该这样说话。&lt;/p&gt;
&lt;p&gt;其实，影视剧使用专门的语言，是业内本就早已熟知的事情。&lt;/p&gt;
&lt;p&gt;只不过，这群业内人士，不从事动画片制作。&lt;/p&gt;
&lt;p&gt;因此，腾讯上播放的那些所谓动画片，统统没有对台词进行优化。不仅仅没有进行优化，反而因为从业者对日本动画片的喜爱，不知不觉的搞出了日式汉语。&lt;/p&gt;
&lt;p&gt;正是这个日式汉语，导致动画片的台词听着别扭。&lt;/p&gt;
&lt;p&gt;日式汉语令人听感不佳的特征点有&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;语速较慢。正常人说话的语速为每分钟 300 - 500 字。腾讯动画片里的人物台词语速不足每分钟200字。&lt;/li&gt;
&lt;li&gt;台词极少出现成语和歇后语。即使是日常生活对话，也是要经常使用成语和歇后语的。腾讯动画片的从业者的日本师傅较少使用台词和歇后语是主要原因。因为日本人汉语水平较低，使用成语会增加观众理解障碍。&lt;/li&gt;
&lt;li&gt;会不经意的夹杂一些日语梗。除了对日本动画片较为熟悉的观众，无法理解。而导演不自知。&lt;/li&gt;
&lt;li&gt;语序经常错乱为日语语序。&lt;/li&gt;
&lt;li&gt;台词词汇上会偏向早年 CCTV 引进日本动画片的时候使用的翻译词汇。而不是本地人所使用的更接底气的词汇。&lt;/li&gt;
&lt;li&gt;待补充&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这就是为何，我更喜欢熊猫人动画片。因为以上问题，熊猫人动画片统统没有。&lt;/p&gt;
&lt;p&gt;不仅仅没有，熊猫人动画片在台词上，会更有文艺范。因为我看的熊猫人动画片，以穿越剧为主。
因此，他们的台词设计上，就会更加学习三国演义。&lt;/p&gt;
&lt;p&gt;虽然熊猫人动画片用 AI 进行配音，看似缺少了感情。但是，台词功底完爆腾讯动画片。观之反而越来越有味。&lt;/p&gt;</description>
    </item>
    <item>
      <title>新型单相电机调速器</title>
      <link>https://microcai.org/2024/03/06/new-ac-motor-speed-controller.html</link>
      <pubDate>Wed, 06 Mar 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/03/06/new-ac-motor-speed-controller.html</guid>
      <description>&lt;h1 id=&#34;传统立扇调速方案&#34;&gt;传统立扇调速方案&lt;/h1&gt;
&lt;p&gt;传统立扇方案主要采用抽头调速方法，通过机械调速开关改变主绕组与辅助绕组接线方式。一般抽头调速的风扇电机是基于满载工况优化设计，在电机高挡位运转时，绕组磁场接近正交的圆形，噪音和效率表现相对较好，而中低挡位时主绕组和副绕组的结构被改变，绕组合成磁场偏向椭圆，电机运行失去对称性，转矩脉动分量增加。并且中低挡位工况下，运行绕组温升更高，电机偏离了原有优化的状态，其输入功率也没有成比例下降，还经常伴随着恼人的电磁噪音。从某种意义来说，抽头调速是靠绕组间“出力抵消“，消耗能量来达到调速目的。此外，因为多抽头绕组结构复杂，实际生产中电机定子绕线需要人工配合，不利于电机标准化生产。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;抽头调速&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/28469021.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;交流调压控速&#34;&gt;交流调压控速&lt;/h1&gt;
&lt;p&gt;实际上，电扇电机因为功率较小，因此可以对只使用变压器进行调速。事实上中间抽头的做法，就是让电机绕组与抽头形成自耦变压器。然后实际上相当于降压运行。并不需要变频就可以完成简易的调速任务。&lt;/p&gt;
&lt;p&gt;但是，抽头法有2个缺点。其一为档位固定。制作的时候做几个抽头就只有几个档位。其二为低速运行的时候效率急剧下降。&lt;/p&gt;
&lt;p&gt;所以，如果使用交流调压器，其实也可以对电机进行调速。&lt;/p&gt;
&lt;p&gt;但是，交流调压器使用工频变压器就决定了，成本低不了。&lt;/p&gt;
&lt;p&gt;传统上，直流降压使用 Buck 电路。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Buck&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/20200414104632358.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;所需元件超少，成本非常低。&lt;/p&gt;
&lt;p&gt;但是，只能对直流电起作用。&lt;/p&gt;
&lt;p&gt;如果有一种对交流电直接进行 Buck 变换的电路，岂不是能大大降低交流电的降压成本？然后超低成本实现单相电机的调速功能？&lt;/p&gt;
&lt;h1 id=&#34;交流-buck-降压电路&#34;&gt;交流 Buck 降压电路&lt;/h1&gt;
&lt;p&gt;&lt;img alt=&#34;ACBuck&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/Snipaste_2024-03-06_02-26-04.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;在上图电路里， 4个 MOS 管构成了一个 H 桥。但是这个 H 桥的输入端，却是 左边右边一个火线一个零线。&lt;/p&gt;
&lt;p&gt;传统的H桥，左半桥和右半桥，输入都是接的直流母线。
但是，这个 ACBuck 的 H 桥，左右却是接的不同的输入。一个火线一个零线。 H桥的下管源级，倒是接的“地”。&lt;/p&gt;
&lt;p&gt;这个“地”，其实是另一处，火零经过全桥整流后的负极。&lt;/p&gt;
&lt;p&gt;在交流的正半周， Q3、Q4 构成一个 buck 降压电路。Q1 Q2 工作在反向电压，由于其体二极管的存在，不论开关管是打开还是关闭，电流都会畅通无阻的流到零线。&lt;/p&gt;
&lt;p&gt;在交流的负半， Q1 Q2 构成了一个 buck 降压电路。Q3 Q4 工作在反向电压。由于其体二极管的存在，不论开关管是打开还是关闭，电流都会畅通无阻的流到火线。&lt;/p&gt;
&lt;p&gt;因此，只要使用一个带死区控制的互补 PWM 信号，就可以无视交流电的正负周期，而直接对交流电进行 Buck 降压。&lt;/p&gt;
&lt;p&gt;每个桥臂的下管，同时还充当续流管的作用。这还是一个同步 Buck 降压电路。&lt;/p&gt;
&lt;p&gt;只需要调节 PWM 信号的占空比，就能调节输出的电压。&lt;/p&gt;</description>
    </item>
    <item>
      <title>TO-252 对比 TO-220</title>
      <link>https://microcai.org/2024/03/03/to252-vs-to220.html</link>
      <pubDate>Sun, 03 Mar 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/03/03/to252-vs-to220.html</guid>
      <description>&lt;p&gt;MOSFET，功率MOS，最常见的外形，就是 TO-252 和 TO-220 两种。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;封装对比图&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/TO252-TO220.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;上图左边的为 TO-252 封装。右侧为 TO-220 封装。&lt;/p&gt;
&lt;p&gt;其实会发现，TO-220 剪掉中间引脚，折弯两边的引脚，也能转变为贴片形式。&lt;/p&gt;
&lt;p&gt;在我设计低压变频器的时候，我一直使用的 TO-252 封装的 MOS。无他，低压的大电流MOS还是TO-252更常见。&lt;/p&gt;
&lt;p&gt;后来，设计220v电压的高压变频器的时候，我转而使用 TO-220 封装的MOS。无他，我观各种使用650v 耐压的mos的电路板，通常使用 TO-220 的直插MOS。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;组装好了&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-02-08_13-17-06.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;但是，自从这个版本炸了MOS后，我改回了 TO-252。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;改回TO-252&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/Snipaste_2024-03-03_19-08-24.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;用回 TO-252 后，便没再炸MOS了。&lt;/p&gt;
&lt;p&gt;虽然，板子的前后区别，可不仅仅是MOS改变了封装。&lt;/p&gt;
&lt;p&gt;首先就是修改后的板子，栅极驱动到MOS管的距离更短了。意味着更小的走线寄生电感。&lt;/p&gt;
&lt;p&gt;其次，驱动桥臂的上管源极和下管漏极之间的距离被无限缩小了。之前使用 TO-220 的时候， 上下桥臂距离可没这个版本近。&lt;/p&gt;
&lt;p&gt;然后是增加了若干退耦电容。&lt;/p&gt;
&lt;p&gt;这都为新板子的稳定运行立下功劳。只是不知道具体是哪个措施真正起了作用😂&lt;/p&gt;
&lt;p&gt;于是，对比了 TO-252 和 TO-220 后，我得出了一个结论：TO-220 可以淘汰了。&lt;/p&gt;
&lt;p&gt;首先，TO-220 需要使用散热片散热。背面金属片上的洞就是方便使用螺丝将mos牢牢固定在散热片上的。而且如果不是一个mos配一个散热片，还得配绝缘的导热垫片。因为TO-220背面的金属散热片，和中间的那个引脚都是漏极。&lt;/p&gt;
&lt;p&gt;在pcb制造的过程中，不得不增加非机械臂可完成的操作————将散热片和mos用螺丝固定到一起。这对人工成本越来越贵的当下显然是徒增成本。&lt;/p&gt;
&lt;p&gt;反观 TO-252 封装，减掉了漏极引脚。直接使用散热片当漏极。并且通过焊锡将散热片和 pcb 的铜箔牢牢焊接到一起。热阻远小于使用硅脂+导热垫片。&lt;/p&gt;
&lt;p&gt;在大部分情况下，使用大面积覆铜就可以出色的替代独立的散热片。&lt;/p&gt;
&lt;p&gt;其次，表贴型MOS的引脚更短。更有利于减小封装引入的寄生电感和寄生电容。这就意味着更高的开关速度，更小的开关损耗。当然，还有更不容易炸管。&lt;/p&gt;
&lt;p&gt;为了能利用好 TO-252 的优势。接下来我设计pcb的时候，会注意给MOS管更大的散热用覆铜。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;走线绕开为覆铜&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-03-03_20-14-05.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;比如上图这个设计，特意将走线进行绕道，就为了能给 MOS 更大的覆铜面积以供散热。&lt;/p&gt;</description>
    </item>
    <item>
      <title>三电平 SVPWM</title>
      <link>https://microcai.org/2024/02/29/3level-svpwm.html</link>
      <pubDate>Thu, 29 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/29/3level-svpwm.html</guid>
      <description>&lt;p&gt;炸机了。&lt;/p&gt;
&lt;p&gt;制作低压变频器的时候，从未出现过炸机。但是，在高压变频器上，出现了。MOS管直接炸开。pcb铜箔炸飞。&lt;/p&gt;
&lt;p&gt;究其原因，还是因为mos关闭时候产生的尖峰电压。&lt;/p&gt;
&lt;p&gt;在研究解决方案的时候，碰到了三电平拓扑。&lt;/p&gt;
&lt;p&gt;三电平拓扑输出三相电需使用12个 MOS 管。&lt;/p&gt;
&lt;p&gt;那么问题来了，12个MOS管，如何控制呢？&lt;/p&gt;
&lt;p&gt;其实，不用修改 svpwm 算法。 svpwm 算法在最终，会输出 A B C 三相的 pwm 值。&lt;/p&gt;
&lt;p&gt;在传统2电平拓扑里，这3个 pwm值，就直接幅值给硬件驱动，产生6路pwm 了。&lt;/p&gt;
&lt;p&gt;在3电平拓扑里，这3个 pwm 值，要转而变成 2个 pwm 定时器的12路 pwm 。&lt;/p&gt;
&lt;p&gt;具体做法为，使用2个定时器。这2个定时器都需要开启6路pwm互补输出模式。对x相来说，有 Qxh1, Qxh2, Qxl1, Qxl2 四个开关。
其中， Qxh1 和 Qxl1 使用1号定时器对应通道。，Qxh2 和 Qxl2 使用2号定时器对应通道。&lt;/p&gt;
&lt;p&gt;对 X 相来说，如果传入的 pwm 值 &amp;lt; 50%, 则，定时器1 的通道输出上管关，下管常开，定时器2的 上下通道输出按 pwm值*2。
如果传入的 pwm 值 &amp;gt;= 50%, 则定时器 2 下管关。 上管常开，1号定时器上下通道输出按 (pwm-0.5)*2。&lt;/p&gt;
&lt;p&gt;比如下面这个代码&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;// duty range from [0-1]
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;set_pwm&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;float&lt;/span&gt; duty_A, &lt;span style=&#34;color:#66d9ef&#34;&gt;float&lt;/span&gt; duty_B, &lt;span style=&#34;color:#66d9ef&#34;&gt;float&lt;/span&gt; duty_C)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (mode &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; TWO_LEVEL_SVPWM)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        driver_set_pwm(TIM1, channel1, duty_A &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        driver_set_pwm(TIM1, channel2, duty_B &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        driver_set_pwm(TIM1, channel3, duty_C &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (mode &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; THREE_LEVEL_SVPWM)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (duty_A &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM1, channel1, &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;); &lt;span style=&#34;color:#75715e&#34;&gt;// 下管常开
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM2, channel1, duty_A&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM2, channel1, perid_count); &lt;span style=&#34;color:#75715e&#34;&gt;// 上管常开
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM1, channel1, (duty_A &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;)&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (duty_B &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM1, channel2, &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;); &lt;span style=&#34;color:#75715e&#34;&gt;// 下管常开
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM2, channel2, duty_B&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM2, channel2, perid_count); &lt;span style=&#34;color:#75715e&#34;&gt;// 上管常开
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM1, channel2, (duty_B &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;)&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (duty_C &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM1, channel3, &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;); &lt;span style=&#34;color:#75715e&#34;&gt;// 下管常开
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM2, channel3, duty_C&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM2, channel3, perid_count); &lt;span style=&#34;color:#75715e&#34;&gt;// 上管常开
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            driver_set_pwm(TIM1, channel3, (duty_C &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;)&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; perid_count);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个代码就实现了3电平 svpwm 输出。而三相duty的计算方式和之前的并无不同。&lt;/p&gt;</description>
    </item>
    <item>
      <title>被销售绑架</title>
      <link>https://microcai.org/2024/02/26/seller-kidnapped-business.html</link>
      <pubDate>Mon, 26 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/26/seller-kidnapped-business.html</guid>
      <description>&lt;p&gt;在芯片销售行业，有一个怪现象。买芯片的人是孙子。&lt;/p&gt;
&lt;p&gt;在线的电子元件商城是行业老鼠，属于行业灰色地带（只是被业内人士定义为灰色。实际上100%合理合法的白色产业）。&lt;/p&gt;
&lt;p&gt;不仅仅买芯片的时候是孙子。在研发 pcb 的时候，更是孙子。需要找芯片厂求来芯片手册。没有手册，就算买到芯片了也用不起来。&lt;/p&gt;
&lt;p&gt;芯片的价格是卖方市场。能打几折买到芯片，就决定了最终产品的竞争力。因此为了赚钱，买方要无下限跪舔卖方的销售。&lt;/p&gt;
&lt;p&gt;如果有这么一个平台，你不用跪销售，就能买到芯片，畅通无阻的查阅各类型号的手册。&lt;/p&gt;
&lt;p&gt;那这个平台一定把芯片销售得罪死。&lt;/p&gt;
&lt;p&gt;销售不仅仅当不了大爷，没有买方舔他了。更重要的是，芯片制造商发现他们不需要这些提成巨大的销售了。这对芯片销售来说是灭顶之灾。&lt;/p&gt;
&lt;p&gt;因此，在销售掌握话语权的公司，你都没法在在线商城里买到他家的芯片。&lt;/p&gt;
&lt;p&gt;不过好在，还有很多公司，销售并不掌控公司。所以元件商场上还是会有各类琳琅满目的芯片可供购买。对他们来说，在线商城，是多了一个销售渠道。
卖东西嘛，渠道是多多益善。&lt;/p&gt;
&lt;p&gt;元件商场常常让人诟病的一个问题是，价格没有优势。&lt;/p&gt;
&lt;p&gt;但是，这不是元件商场的错。因为他们是在芯片原厂的销售抵制的情况下开起来的。为了喂饱这些销售，元件商场的拿货价，都比你直接找销售买的高。&lt;/p&gt;
&lt;p&gt;因此，他们的目标客户，就只能是那些体量较小，舔不起销售的初创公司以及DIY爱好者了。&lt;/p&gt;
&lt;p&gt;芯片公司有一个很诡异的地方。就是芯片公司的官网。只要你用了他的芯片，你就一定要去他官网下文档&lt;/p&gt;
&lt;p&gt;也就是说，你的客户必然会访问你的官网&lt;/p&gt;
&lt;p&gt;那么，此时你在官网直接销售芯片。厂家直销，是水到渠成的。&lt;/p&gt;
&lt;p&gt;正是为了避免发生这种情况，销售才会忽悠公司说，芯片的手册是机密，不能公开。只能通过销售传给买了芯片的人。&lt;/p&gt;</description>
    </item>
    <item>
      <title>FlyBuck的限制</title>
      <link>https://microcai.org/2024/02/25/flybuck-limitation.html</link>
      <pubDate>Sun, 25 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/25/flybuck-limitation.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/02/21/power-on-pcb.html&#34;&gt;这篇&lt;/a&gt; 文章里，我夸奖了 flybuck 拓扑结构。&lt;/p&gt;
&lt;p&gt;不过，在实际使用的时候，发现 flybuck 并没有想象中那么美好。&lt;/p&gt;
&lt;p&gt;第一点，flybuck 并不是任何 buck 芯片都能工作。而是只有能工作在强制 CCM 模式的 同步整流buck 芯片才能工作。
因此只有 Ti 的寥寥数个芯片，被打上了 FlyBuck 标志的才能用在 flybuck 上。而因为 FlyBuck 是 Ti 的商标，
所以其他公司的芯片，是不会打上这个标记的。只能通过仔细阅读芯片手册，确定他可以工作在强制 CCM 模式。
这就要了老命了。因为市面上的 DCDC 降压芯片超过一万款。&lt;/p&gt;
&lt;p&gt;第二点，flybuck 的输出电压也不是 Vout2 = Vout1 * Np/Ns - Vf。而是受漏感影响。
在有漏感的情况下，Vout2 的电压还会同时受 Iout1 和 Iout2 相互影响。&lt;/p&gt;
&lt;p&gt;漏感大了，副边电压就稳不住了。这也要了老命了。因为本来是低成本的方案，结果对变压器的要求很高。漏感低的耦合电感可一点都不便宜。&lt;/p&gt;
&lt;p&gt;实际上，超过2元成本的 flybuck 毫无意义。因为有不到3元的 flyback 方案。
但是 Ti 标记能用于 FlyBuck 的 dcdc  芯片，个个都在两位数价格。毫无成本优势。
Ti  所谓的flybuck的成本优势，是建立在Ti 家的 flyback芯片更贵的基础上的。
当国内厂家生产5毛钱的flyback芯片时，ti 的 flybuck 优势荡然无存。&lt;/p&gt;
&lt;p&gt;因此我只能寄托于国内厂家3毛钱的 buck芯片能用于 flybuck。
但是国内厂家的一个通病就是手册喜欢藏着掖着。生怕用户知道芯片怎么用。
于是关键的信息，芯片是否CCM模式，如何强制CCM模式的信息，是断然不会提供的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>LLC 真的是天才发明</title>
      <link>https://microcai.org/2024/02/23/llc-is-a-brillant-invention.html</link>
      <pubDate>Fri, 23 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/23/llc-is-a-brillant-invention.html</guid>
      <description>&lt;h1 id=&#34;开关电源&#34;&gt;开关电源&lt;/h1&gt;
&lt;p&gt;传统上，交流电通过一个巨大的变压器进行变压。因为交流电通过磁耦合的方式传递能量。传递能量的频率为交流电的频率。每次传递的能量取决于变压器铁芯的磁通量。磁通量从最大到最小，最小到最大，
经历一次能量传递。&lt;/p&gt;
&lt;p&gt;变压器要增大功率，要么增加磁通，要么提高频率。显然工作在50hz交流电下的变压器，只能选择增大磁通的方式增加功率。由于材料能承受的磁通量密度是有上限的。过大的磁通密度会饱和。所以变压器要增加功率，只能增加体积。&lt;/p&gt;
&lt;p&gt;而开关电源，则另辟蹊径，使用晶体管的开关功能产生高频的交流电，从而摆脱了 50hz 的频率限制。&lt;/p&gt;
&lt;p&gt;于是，体积很小的变压器就可以传递很大的功率。&lt;/p&gt;
&lt;p&gt;在如何产生高频交流电的问题上， 产生了很多种路径。&lt;/p&gt;
&lt;p&gt;反激，正激，推挽，全桥。&lt;/p&gt;
&lt;p&gt;当中最为广泛使用的，属反激。但是不管是反激，正激，推挽还是全桥，变压器的漏感，都属于有害的东西。要尽量减小。
所谓变压器的漏感，指变压器初级的一部分能量没有传递给次级，而是滞留在初级，导致初级滞留的能量最后在开关管关断的时候要释放出来。
这部分释放能量需要在初级电路里消纳掉，导致电源整体效率下降。&lt;/p&gt;
&lt;h1 id=&#34;漏感利用&#34;&gt;漏感利用&lt;/h1&gt;
&lt;p&gt;人类历史上很多东西的进步都来自变废为宝。比如 LLC 的发明，就将废物的漏感变成了宝。&lt;/p&gt;
&lt;p&gt;要理解 LLC 首先要理解 LC。L 和 C，一个电压滞后，一个电流滞后。搭配起来干活的时候，恰好会反复将对方滞后。。。  也就是俗称的振荡。
也就是一个 L 一个 C, 就构成了一个振荡电路。电流会反复的在 L 和 C 之间徘徊。&lt;/p&gt;
&lt;p&gt;变压器的初级绕组，也是一个线圈绕在铁芯上。他就会是一个电感。在进行电路分析的时候，变压器的电感会被拆分成2个。一个是主电感，一个是漏电感。主电感负责把能量传给次级。
漏电感。。。漏电感负责搞事情。&lt;/p&gt;
&lt;p&gt;这搞事情的漏电感，在 LLC 的眼中，却是好东西。因为他可以和电容构成 LC 振荡。因为主电感把能量输送给次级后，自身就没有能量了，也就是说，变压器的次级接了负载后，主电感的感量就被消耗掉了。
所以，没有漏感的理想变压器，反而不能引起 LC 振荡。必须得再搭配一个L。而反正非理想变压器免费送一个漏感。于是 LLC 就把这个漏感笑纳了。&lt;/p&gt;
&lt;p&gt;在 LLC 里，漏感（固定值），主电感（随负载变动），电容三者构成了一个谐振电路。这个谐振电路恰好能产生交流电，然后这个交流电又恰好发生在变压器的线圈里，于是这个谐振能量就传递给了变压器的次级。&lt;/p&gt;
&lt;p&gt;随着负载的变动，谐振点也会跟着移动。如果驱动电路产生的 pwm 频率和谐振频率不同，就会损失效率。表现为次级电压下降。因此采集次级的电压，可以用于修正 pwm 的频率。让 pwm 的频率始终保持在谐振频率上。因为，如果 pwm 的频率和谐振频率相同，就会产生一种神奇的效果。 就是 MOS 管开关的时间点，正好在谐振电压为0的地方。也就是，产生了 0 压开启的效果。使得mos管的开通损失降为0。&lt;/p&gt;
&lt;p&gt;因此 LLC 的次级电压反馈，主要目的不是为了调整占空比稳压（因为 LLC 始终使用 50% 的占空比，也就是pwm只是单纯的维持谐振电路，而不是调节占空比来调压），而是为了跟踪谐振频率。&lt;/p&gt;</description>
    </item>
    <item>
      <title>变频器制作-第12部分 电源，还是电源</title>
      <link>https://microcai.org/2024/02/21/power-on-pcb.html</link>
      <pubDate>Wed, 21 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/21/power-on-pcb.html</guid>
      <description>&lt;h1 id=&#34;说到供电&#34;&gt;说到供电&lt;/h1&gt;
&lt;p&gt;一个变频器，需要4组电压供电，分别是 DC 300V, DC 12V, DC 5V, 隔离 5V.&lt;/p&gt;
&lt;p&gt;300v 是高压， 12v 和 5v 乃低压。&lt;/p&gt;
&lt;p&gt;只不过， 12v 和 5v 和 300v 的高压，负极是连到一起的。因此，这个负极，是不安全的负极。这个负极，是整流桥的负极。这个负极会有一个对地的脉动电压。&lt;/p&gt;
&lt;p&gt;其中， 300V DC 由一个整流桥 + 一个 LC 滤波器获得。&lt;/p&gt;
&lt;p&gt;12V 是专门给栅极驱动器供电的。NMOS 一般使用 12V 门级电压确保完全开启。
5v 是给隔离器的高压侧供电的。隔离5v 则是给隔离器的低压侧，和其他需要安全的隔离的电路供电。比如 mcu，显示屏等。&lt;/p&gt;
&lt;h1 id=&#34;使用成品5v小电源获得供电&#34;&gt;使用成品5v小电源获得供电&lt;/h1&gt;
&lt;p&gt;12v 属于低压。在传统上，会使用一个开关电源获取低压供电。
我最初也是这么设计的。由于我并不是电源工程师，所以购买的成品开关电源模块。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;成品模块&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/acdc_mod.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;图中红圈的就是成品开关电源模块。一共使用了2个。其中一个用于提供隔离的5V。另一个则是将输出的负极和高压侧的 GND 连接。以获得非隔离的 5V 供电。然后再使用一个 DCDC 升压芯片获得一个非隔离的12v。当然，如果使用12v 输出的隔离模块，然后使用 dcdc 降压，同样能达成目的。不过这就意味着要购买两种电源模块。会增加 BOM 成本。&lt;/p&gt;
&lt;p&gt;由于使用了成品的开关电源，使得220v变频器的成本里有个无法压缩的2个开关电源模块。而且这种模块必须手焊，无法使用自动化的贴片流水线。凭空增加成本。&lt;/p&gt;
&lt;h1 id=&#34;使用-dcdc-芯片获得12v&#34;&gt;使用 DCDC 芯片获得12v&lt;/h1&gt;
&lt;p&gt;由于板子上有非隔离的12v供电的需求。因此转而使用了DCDC降压芯片获得12v供电。&lt;/p&gt;
&lt;p&gt;大部分DCDC芯片都是为低压的直流转直流设计的。无法耐受高压。但是，架不住人们对成本压缩的渴望。芯片公司转而研发了输入耐压能到 600V 的 DCDC 降压模块。用于将 整流后的 310v 直流电直接降压为低压。相比低压的dcdc芯片，这种非隔离的dcdc芯片仍然被归类到 ac/dc 电源芯片里。但是实际上其架构就是普通的 Buck 降压电路。因此他的成本也就比普通的dcdc芯片多几毛钱。&lt;/p&gt;</description>
    </item>
    <item>
      <title>变频器制作-第11部分 pwm模式用对了吗？</title>
      <link>https://microcai.org/2024/02/08/pwm-mode-misuse.html</link>
      <pubDate>Thu, 08 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/08/pwm-mode-misuse.html</guid>
      <description>&lt;h1 id=&#34;话说高级定时器&#34;&gt;话说高级定时器&lt;/h1&gt;
&lt;p&gt;不管是 AT32 还是 CH32 还是 EG32 还是 GD32 还是 RP32. 各种 32 单片机，都是使用的 防STM32 的外设。&lt;/p&gt;
&lt;p&gt;因此，他们都会有一种叫“高级定时器”的设备，用来产生多路互补PWM波。&lt;/p&gt;
&lt;p&gt;在高级定时器的设置里，能产生的波形是以下机制的排列组合&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;计数器模式
向上计数溢出置0，向下计数到0重置，向上然后向下计数。后两者称为中央对称模式。在 svpwm 里，固定使用中央对称模式。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;通道大于占空比值输出真，大于占空比值输出假。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;真值高电平 真值为低电平&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;有些hal库，上管通道和下管通道可以分别设置 2 号模式。有些没有独立设置。不知道是硬件如此还是hal库认为没必要暴露这种设定。&lt;/p&gt;
&lt;p&gt;2 号 和3 号设定，有互补性。比如 （通道大于占空比值输出真+真值高电平）和 （大于占空比值输出假+真值为低电平）的组合，产生的 pwm 波是一模一样的。&lt;/p&gt;
&lt;p&gt;一开始，我并没有在意，感觉是硬件上可能会做一些没有意义的组合机制。比如 三个上管打开和3个下管同时打开，作用是一样的，在 svpwm 里都是属于0向量。&lt;/p&gt;
&lt;h1 id=&#34;再谈死区时间&#34;&gt;再谈死区时间&lt;/h1&gt;
&lt;p&gt;最初我制作12v的低压变频器的时候，并没有在单片机里设定死区时间。因为栅极驱动已经内置了一个死区时间。&lt;/p&gt;
&lt;p&gt;6pwm 模式相比 3pwm 模式，死区可调的优势当时我是不知道的。我只不过是希望能有6管同时关闭的模式。所以即使不需要死区控制，我也使用了6pwm 模式。&lt;/p&gt;
&lt;p&gt;直到后来，我开始向220v进发。高压 MOS 相比低压 MOS 具有更大的导通和关断延迟。栅极驱动里默认的延迟时间显得不太够用了。&lt;/p&gt;
&lt;p&gt;由此，6pwm 模式软件可调死区的优势就是必须的了。&lt;/p&gt;
&lt;p&gt;在设定一个死区时间后，我就上机调试了。发现电路能正常运行，并且没有炸鸡。我以为大功告成了。&lt;/p&gt;
&lt;p&gt;然而，我的眼花悄悄的给我开起了玩笑。&lt;/p&gt;
&lt;h1 id=&#34;被pwm模式的的排列组合暴击&#34;&gt;被pwm模式的的排列组合暴击&lt;/h1&gt;
&lt;p&gt;之前讲过，（通道大于占空比值输出真+真值高电平）和 （大于占空比值输出假+真值为低电平）的组合，产生的 pwm 波形是一样的。&lt;/p&gt;
&lt;p&gt;事实上，我确实就随意的选了一种模式，并且当时恰好能工作。&lt;/p&gt;
&lt;p&gt;其实，这个结论，只有不使用死区控制的时候是正确的。 使用了死区控制，结论就不正确了。
因为，这关系到，单片机在输出死区这段时间，是上下管的 pwm 波同时高电平，还是同时低电平。&lt;/p&gt;
&lt;p&gt;而且我恰好把这个设置弄反了。结果就是，单片机在死区时间，输出模式乃上下管同时高电平。&lt;/p&gt;
&lt;p&gt;而栅极驱动确实尽职尽责。在单片机输出上下同开的错误命令的时候，检测到了错误，忠实的完成了自己的“防上下管同开”的任务。于是恰好，没有炸管。&lt;/p&gt;
&lt;p&gt;但是突然有那么一个瞬间，栅极驱动不灵了。他未能完成他的任务。上下管同时导通了！&lt;/p&gt;</description>
    </item>
    <item>
      <title>变频器制作-第十部分 6pwm和死区时间</title>
      <link>https://microcai.org/2024/02/06/deadtime-important.html</link>
      <pubDate>Tue, 06 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/06/deadtime-important.html</guid>
      <description>&lt;h1 id=&#34;3pwm-vs-6pwm&#34;&gt;3pwm vs 6pwm&lt;/h1&gt;
&lt;p&gt;三相桥需要6个开关管。控制6个开关管需要控制器输出六路pwm信号。&lt;/p&gt;
&lt;p&gt;这将占用单片机6个 IO 口。考虑到 pwm 信号控制的开关管中，上下管是交替导通的。也就是所谓的互补。
因此在一些场景下，也可以使用 3pwm 模式控制6个开关管。
3pwm的信号控制3个上管，对应的下管控制信号由一个反相电路生成。&lt;/p&gt;
&lt;p&gt;咋一看，似乎节约了3个IO引脚。诞生 3pwm模式有一个重要功能无法实现，就是让6个开关管全关。&lt;/p&gt;
&lt;p&gt;因此为了表示这个全关状态，实际上需要额外增加一路 EN 信号。因此 3pwm 模式需要使用4个引脚。&lt;/p&gt;
&lt;p&gt;听上去不错，在实现相同功能的情况下，节约了2个引脚。&lt;/p&gt;
&lt;p&gt;但是，我想说的是，&lt;strong&gt;如果有条件，千万不要使用 3pwm 模式&lt;/strong&gt;。&lt;/p&gt;
&lt;h1 id=&#34;死区时间控制&#34;&gt;死区时间控制&lt;/h1&gt;
&lt;p&gt;理想是丰满的，现实是骨感的。现实中的开关管，并不总是能立即导通/关闭。&lt;/p&gt;
&lt;p&gt;导通和关闭都需要一定的时间发生。如果上管关信号给出的时候，立即给出下管开信号，或者下管关信号给出的时候立即给出上管开信号，也就如使用反相器电路做的那样，则会导致上下管会在某个时间里处于同时打开的状态。&lt;/p&gt;
&lt;p&gt;这会导致严重的短路。&lt;/p&gt;
&lt;p&gt;所以，互补的pwm信号比如插入死区时间。所谓死区时间，就是在上下管切换开启的时候，中间插入两个管子都关闭的时间。以保证实际的管子不会出现同时打开的情况。&lt;/p&gt;
&lt;p&gt;在 3pwm 模式，死区时间需要由硬件设计达成。一般是通过在反相器电路里插入延时实现。&lt;/p&gt;
&lt;p&gt;在现实世界中，一般是使用集成了死区时间控制的栅极驱动器芯片达成目的。&lt;/p&gt;
&lt;p&gt;但是，栅极驱动器的死区控制是死的。一旦选定，就无法更改了。&lt;/p&gt;
&lt;p&gt;因此，为了电路的灵活调整需要，最好是在单片机里控制 pwm 信号的死区时间。&lt;/p&gt;
&lt;p&gt;这就宣判了 3pwm 模式的死刑。&lt;/p&gt;
&lt;h1 id=&#34;死区时间设置多大&#34;&gt;死区时间设置多大&lt;/h1&gt;
&lt;p&gt;在 MOS 管的手册里，会给出 4 个 delay time。分布是开通延时，上升延时。关闭延时，下降延时。&lt;/p&gt;
&lt;p&gt;并且这4个时间还会给出 最小值，典型值，和最大值。&lt;/p&gt;
&lt;p&gt;单片机pwm输出配置的死区时间 = 最大关闭延迟+最大下降延时 - 最小开通延迟  - 栅极驱动器的最小死区时间。&lt;/p&gt;
&lt;p&gt;&lt;em&gt;如果为负，就无需设置死区时间了。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;之所以突然要考虑死区这个问题，是因为最近我开始将变频器给高压化。而高压的 MOS管，其导通延时大大增加。目前选定的一款 MOS， 耐压650V，导通内阻 &amp;lt; 300mΩ，价格不到1元一片。
如此低廉的价格，伴随的是高达450nS的关闭延迟，高达 2000pF 的寄生电容。&lt;/p&gt;
&lt;p&gt;经过计算，发现需要800nS 的死区时间。而栅极驱动器的 死区时间是 200nS。。可见如果不在软件上插入死区时间，必然会炸管。&lt;/p&gt;</description>
    </item>
    <item>
      <title>220v 逆变器大功告成</title>
      <link>https://microcai.org/2024/02/05/220v-vfd-success.html</link>
      <pubDate>Mon, 05 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/05/220v-vfd-success.html</guid>
      <description>&lt;h1 id=&#34;起&#34;&gt;起&lt;/h1&gt;
&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/01/17/add-eg6832-to-platformio.html&#34;&gt;这篇&lt;/a&gt; 文章里，我被风扇厂的老板教育了成本控制。&lt;/p&gt;
&lt;p&gt;思来想去，我发现还是有必要制作 220v 的变频器以降低对电机的要求。&lt;/p&gt;
&lt;p&gt;经过数次炸板改版后，最终在今天制作完成了。听到家里 220v 的电机，而不是自己改绕的电机，也发出了熟悉的 vvvf 音乐，心情还是非常激动的。&lt;/p&gt;
&lt;h1 id=&#34;制作&#34;&gt;制作&lt;/h1&gt;
&lt;p&gt;首先， 220v 属于强电，而单片机实验 3.3v 属于弱电。强电和弱电需要隔离。
我首先想到的是使用光耦进行隔离。&lt;/p&gt;
&lt;p&gt;但是，一想到要在pcb上贴6个光耦就感觉成本飙升。而且光耦的 LED 发光二极管，总感觉会随着时间的推移而衰减。而且还感觉 LED 二极管的发光熄灭的速度赶不上 pwm 的速度。&lt;/p&gt;
&lt;p&gt;事实也确实如此。因此需要使用专门为栅极驱动设计的高速光耦。而高速光耦就贵了很多。简直就是成本炸裂。&lt;/p&gt;
&lt;p&gt;就在我苦恼的时候，突然发现了数字隔离器这种东西。一个数字隔离器和一个高速光耦价格相当，但是光耦只能传递一路信号，而数字隔离器能传多路。成本一下子就节约下来了。 最后选了一个6路的数字隔离器，只需一个就完成了6路 pwm 信号的传递。&lt;/p&gt;
&lt;p&gt;另外，为了适应高压，栅极驱动也需要更换为耐压 600v 的版本。&lt;/p&gt;
&lt;p&gt;因为用惯了EGmicro的栅极驱动，所以想都没想，就从 EG2134 升级成了 EG2334。&lt;/p&gt;
&lt;p&gt;于是驱动电路就从&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;低压&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/EG2134.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;变成了&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;高压&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/EG2334.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;当然，为了对比，也做了一个光耦的版本&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;光耦版&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/EG2334_Optocoupler.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;NOTE：经过光耦后，信号反相了。因此需要在单片机里修改输出极性。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;打样回来的光耦版本&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;制作好的光耦&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-02-08_13-14-23.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;打样回来的数字隔离器版本&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;打样回来的数字隔离器版本&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-02-08_13-14-27.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;除了要使用隔离器进行隔离，栅极驱动和单片机，还得使用两个不同的开关电源供电。
由于我神功还没大成，因此我买了专门的超迷你开关电源模块。
还为这个电源模块在立创EDA里绘制了封装。这样就可以直接引用了。&lt;/p&gt;
&lt;p&gt;比如看下背面&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;背面&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-02-08_13-22-33.jpg&#34;&gt;
有两个电源模块的位置。&lt;/p&gt;
&lt;p&gt;然后搞起来验证&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;组装好了&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/photo_2024-02-08_13-17-06.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;因为家里能给我折腾的就只有电风扇。所以三相接了2相出来，也能用来驱动电风扇的电机了。&lt;/p&gt;
&lt;p&gt;还接了个漏保来保护自己。嘿嘿。&lt;/p&gt;
&lt;p&gt;最后，接上电风扇后，听到了熟悉的 VVVF 声音！&lt;/p&gt;
&lt;h1 id=&#34;总结&#34;&gt;总结&lt;/h1&gt;
&lt;p&gt;高压变频器，增加了隔离成本。所以没法和12v/24v的变频器竞争成本。&lt;/p&gt;
&lt;p&gt;隔离成本大头是多了2个隔离电源，多了数字隔离器，还要使用昂贵的隔离采样放大器。&lt;/p&gt;
&lt;p&gt;而且超过 70w 功率，还得配置 PFC 电路。&lt;/p&gt;
&lt;p&gt;还得想办法，把成本扣出来，这样才能卖给电风扇长。毕竟异步电机 60w 也才十几块钱。能制作低成本的变频器，就不需要 20w 的无刷电机做的“变频风扇”忽悠人了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>单片机也能支持 co_await 协程啦</title>
      <link>https://microcai.org/2024/02/02/awaitable-for-mcu.html</link>
      <pubDate>Fri, 02 Feb 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/02/02/awaitable-for-mcu.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2023/12/08/cooperative-multitasking-in-mcu.html&#34;&gt;这篇文章&lt;/a&gt; 里，我为单片机编写了一个简单的 executor。
然后利用这简单的 executor, 再搭配 Duff&amp;rsquo;s device 就用上了 stackless coroutine 了。&lt;/p&gt;
&lt;p&gt;但是，Duff&amp;rsquo;s device 也有其缺陷。最明显的就是，在 ASIO_CORO_REENTER(this){ xx } 的函数体里，无法定义变量，也无法使用 switch 指令。&lt;/p&gt;
&lt;p&gt;这挺让人头疼的。&lt;/p&gt;
&lt;p&gt;于是，我迫切的需要一个有栈的协程。 c++23 里带的coroutine就不错。&lt;/p&gt;
&lt;p&gt;最初的计划是移植 asio。
但是 asio 不知为何，在 arm-gcc 上遇到了诡异的语法错误。&lt;/p&gt;
&lt;p&gt;遂放弃。直到最近，突然又想起来这件事。&lt;/p&gt;
&lt;p&gt;然后又开始琢磨怎么写一个 awaitable。
但是实在是毫无头绪。于是准备抄一个库。&lt;/p&gt;
&lt;p&gt;然后找到了阿里巴巴开源的 &lt;a href=&#34;https://github.com/alibaba/async_simple&#34;&gt;async_simple&lt;/a&gt; 库。
经过了一定的裁剪后，跑起来了。&lt;/p&gt;
&lt;h1 id=&#34;阿里的代码不和谐&#34;&gt;阿里的代码不和谐&lt;/h1&gt;
&lt;p&gt;首先，阿里的这个协程库，我是扣了代码的。把不需要的东西都删了。但是也没有完全删干净。还有不少遗留的垃圾。
这就让本就捉襟见肘的单片机存储空间更局促了。&lt;/p&gt;
&lt;p&gt;其次，阿里的这个代码虽然已经比 asio 的简化了很多，但是还是弯弯绕绕非常多，非常不利于分析。&lt;/p&gt;
&lt;p&gt;所以，在&lt;a href=&#34;https://www.jackarain.org/&#34;&gt;哥们&lt;/a&gt; 的帮助下，整了一个更简化的&lt;a href=&#34;https://github.com/microcai/mcu_coro_demo/tree/master/lib/mcu_coro&#34;&gt;版本&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;正如 这个仓库里的 例子那样，使用这个协程的方法很简单，首先，需要在 &lt;code&gt;loop()&lt;/code&gt; 里调用 &lt;code&gt;mcucoro::executor::system_executor().poll();&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;然后，这么定义协程&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;mcucoro&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; led_blinker()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt;(;;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  LL_GPIO_TogglePin(GPIOB, GPIO_PIN_14);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;coro_delay_ms&lt;/span&gt;(&lt;span style=&#34;color:#ae81ff&#34;&gt;1240&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;协程的返回值得是 &lt;code&gt;mcucoro::awaitable&amp;lt;void&amp;gt;&lt;/code&gt; 类型，&lt;/p&gt;</description>
    </item>
    <item>
      <title>准备制作直流UPS</title>
      <link>https://microcai.org/2024/01/28/dcups-prepare.html</link>
      <pubDate>Sun, 28 Jan 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/01/28/dcups-prepare.html</guid>
      <description>&lt;h1 id=&#34;问题&#34;&gt;问题&lt;/h1&gt;
&lt;p&gt;现在很多需要停电维持工作的东西，其实都是直流供电的。比如监控。比如树莓派，比如路由器，比如光猫。&lt;/p&gt;
&lt;p&gt;在万能的宝上搜索直流UPS，是能找到一些现成的产品。&lt;/p&gt;
&lt;p&gt;但是，统统不是我设想中的那种工作方式。&lt;/p&gt;
&lt;p&gt;我设想中的UPS，既不是后备式，也不是在线式。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;后备式UPS，在市电正常的情况下，电池处于充电状态。当检测到市电故障，则立即将输出切换到电池。
在线式UPS，电池一直处于边冲边放状态。负载一直都是由电池供电。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;后备式UPS，有切换延时问题。在线式UPS，能量过了好几道，效率太差。&lt;/p&gt;
&lt;p&gt;我设想中的UPS，应该是这样子的&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;负载和电池直接并联。电池不仅供电，还能负责稳压。
充电器为负载供电的同时为电池充电。
充电器的功率只要略大于负载的平均功率。负载短时的功率需求由电池提供（所谓稳压）
电池尽量以恒流方式充电。也就让充电器的输出电流恰好等于电池的充电电流+负载的消纳电量
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这看起来不还是在线式UPS吗？但是在线式UPS是输出电池逆变后的交流电。而直接和电池并联的在线式ups，并不需要逆变。省掉了逆变这一过程。&lt;/p&gt;
&lt;p&gt;那万能的宝上卖的路由器UPS不是这样的吗？&lt;/p&gt;
&lt;p&gt;看起来是，但是并不是。他们使用的还是在线式UPS架构，不过把逆变220v交流电的模块换成了从电池升压输出12v的模块。能量还是要经过  12v适配器-&amp;gt;（ups充电器-&amp;gt;电池-&amp;gt;ups升压电路）-&amp;gt;负载 这么一个过程。能量损失巨大。而且电池实际上充电的速度，取决于负载的消耗能力。负载消耗的大了，电池充电的就慢了。也就是没有做到让电池恒流充电。&lt;/p&gt;
&lt;p&gt;另外也有使用后备式架构的直流UPS。他们使用2个12v适配器，一个为电池供电，一个为负载供电。市电故障的时候，立即切换到12v电池直接供电。这个能做到恒流充电了，但是需要制作2个12v开关电源了。成本上升。&lt;/p&gt;
&lt;p&gt;而且，统统有一个问题：没有48v版。&lt;/p&gt;
&lt;p&gt;为啥需要48v呢？因为 POE。家里需要UPS的设备，全部都是从 POE 交换机取电的。路由器，用 poe 供电。光猫，用 poe 供电。 AP，更是直接接到 POE 上。监控摄像头，也是 POE 供电。&lt;/p&gt;
&lt;p&gt;整个供电的重任，就交到了POE交换机的手上。&lt;/p&gt;
&lt;p&gt;而 POE 交换机，就是以 48v 蓄电池供电为基础设计的。
POE 的供电电压，54v，就是48v蓄电池的浮充电压。&lt;/p&gt;
&lt;h1 id=&#34;解决办法&#34;&gt;解决办法&lt;/h1&gt;
&lt;p&gt;我当然不满足于只是制作一个48v的直流ups填补一下空白。&lt;/p&gt;
&lt;p&gt;于是我想到了一个万能直流UPS，这个万能直流UPS是这样的&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 有2个端口。一个为充放电口，一个为电池接头
2. 使用的时候，连线如下
&lt;/code&gt;&lt;/pre&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;开关电源 ====== 用电器
         ||
        万能UPS == 电池
&lt;/code&gt;&lt;/pre&gt;&lt;pre&gt;&lt;code&gt;3. 万能UPS的充放电口，直接并联在开关电源和用电器的直流母线上。万能UPS的唯一功能，是对流入电池的电流进行限流。也就是进行恒流充电。
4. 如果充电器无输出，则电池可以直接从万能UPS直通用电器。
5. 开关电源的输出电压，应该为电池的满电电压
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是万能UPS，正向工作为Buck 降压恒流模式，反向为直通模式。而且只需要恒流，不需要知道电池的电压。只要适配器的输出电压为电池的满电电压即可。&lt;/p&gt;
&lt;p&gt;实际上，一个简单的带恒流功能的 DCDC 降压模块，就能完成这个万能UPS的工作。除了。。。。一个小问题。&lt;/p&gt;
&lt;h1 id=&#34;难倒了&#34;&gt;难倒了&lt;/h1&gt;
&lt;p&gt;为了减少损害，反向工作的时候，不能依赖开关管的寄生二极管实现自动反向，而应该让 mos 管直接持续导通。
而且为了实现电池接近满电后，buck电路的输入电压=输出电压，也需要让 buck 电路的pwm占空比达到 100%。&lt;/p&gt;</description>
    </item>
    <item>
      <title>编译期对象构造优化 .bss 为 .rodata</title>
      <link>https://microcai.org/2024/01/22/constexpr-constructor.html</link>
      <pubDate>Mon, 22 Jan 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/01/22/constexpr-constructor.html</guid>
      <description>&lt;h1 id=&#34;问题&#34;&gt;问题&lt;/h1&gt;
&lt;p&gt;为了提高性能，我编写了一个查表法算 sin 的函数。为了适配不同 ROM 大小的 mcu, 这个表还有大有小多个版本。最大的表，里面有 1800 项，因为是保存的 0-90度的 sin 指，因此分辨率达到了 0.05度。&lt;/p&gt;
&lt;p&gt;而且，为了进一步提高性能，表里存放的，并不是 float, 而是我自己编写的定点数 float_number。&lt;/p&gt;
&lt;p&gt;问题就出在这个float_number 上。&lt;/p&gt;
&lt;p&gt;因为这个定点表我是这么写的&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;static&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; float_number sin_table[] &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; float_number(&lt;span style=&#34;color:#ae81ff&#34;&gt;0.0&lt;/span&gt;),
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; float_number{&lt;span style=&#34;color:#ae81ff&#34;&gt;0.000872664515&lt;/span&gt;},float_number{&lt;span style=&#34;color:#ae81ff&#34;&gt;0.001745328366&lt;/span&gt;},float_number{&lt;span style=&#34;color:#ae81ff&#34;&gt;0.002617990887&lt;/span&gt;},
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; ......
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;因为这个表，其内存放的并不是内置类型。而是我自己编写的 float_number 类。这是一个定点数类， 使用 C++ 的运算符重载机制，可以做到无缝替换 float, 实现浮点改定点。&lt;/p&gt;
&lt;p&gt;但是，正因为这个类不是内置类型，于是编译器实际上安排的是，将 &lt;code&gt;0.0, 0.000872664515&lt;/code&gt; 等数字，存于 .rodata 段，然后将 sin_table 事实上分配于 .bss 段。
并在初始化代码里将 .bss 段的 sin_table 用存于 .rodata 段的各大 double 数据进行初始化。&lt;/p&gt;
&lt;p&gt;也就是说，这个  sin 表，实际上即占用了 .rodata 也占用了 .bss 。而 .bss 段占用的是mcu里更为珍贵的RAM。
之所以最近才思考这个问题，是因为 EG6832 只有区区 8K 的 RAM。相比拥有 384K 的 ESP32 和 32K RAM 的 AT32, 这个 mcu 的内存实在过于珍贵。
以至于我很快遇到内存不足的问题。&lt;/p&gt;</description>
    </item>
    <item>
      <title>让 PlatformIO 支持 EG6832</title>
      <link>https://microcai.org/2024/01/17/add-eg6832-to-platformio.html</link>
      <pubDate>Wed, 17 Jan 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/01/17/add-eg6832-to-platformio.html</guid>
      <description>&lt;p&gt;近来做变频器，也研究了不少mcu。让我的代码移植到了 ESP32, ESP32S3, ESP32C3, RP2040, STM32F405, AT32F415, AT32F421。
这些 mcu 都有一个共同点： platformio 支持。其中 ESP32, ESP32S3, ESP32C3, RP2040, STM32F405 受 platform 官方支持，而
AT32F415, AT32F421 则有 雅特力 的官方 github 上开放的 platformio 支持包。&lt;/p&gt;
&lt;p&gt;但是，如果有一款 MCU 不被 platformio 支持，官方也不给支持包，咋办？&lt;/p&gt;
&lt;p&gt;作为一个程序员，如果IDE的底层逻辑不了解透彻，寝食难安。&lt;/p&gt;
&lt;p&gt;好在我不是专业的嵌入式开发者。不了解就不了解吧。&lt;/p&gt;
&lt;p&gt;直到，我准备量产我的变频器。在 “得算力者得天下” 作者的帮助下，我找到了位于宁波的一家电器厂。它为杂牌落地扇贴牌生产。我把我的变频器介绍给了它的老板。&lt;/p&gt;
&lt;p&gt;结果碰了一鼻子灰。主要是我的变频器成本太高了。高达25元（那是按在嘉立创进行1000张小批量生产的报价）（虽然市面上最廉价的三相变频器也得三位数购买）！
低端制造业就是这样，对成本斤斤计较。虽然我25元的变频器，可以支持到 200w 的电机。但是人家电风扇只需要 20w。他现在要改用 直流电机。
直流电机的成本比变频器+交流电机的成本更低。虽然60w 的直流电机很贵，但是电风扇只要20w 就行了。 20w 的直流电机就很便宜了。所以 60w 的交流电机+变频器的方案，在12w 直流电机面前毫无招架之力。
后来我准备走的时候，遇到了给他供应12w直流电机的供应商。我向他咨询了直流电机的成本。意外的发现，他的直流电机上的控制器，成本只要6元！&lt;/p&gt;
&lt;h1 id=&#34;6-元&#34;&gt;6 元！！！&lt;/h1&gt;
&lt;p&gt;这是什么神仙成本。&lt;/p&gt;
&lt;p&gt;其实直流电机的控制器在硬件上 = 变频器+转子位置传感器。所以是不可能比变频器更便宜的。所以，其实我的变频器也可以跑在那种 6 元的硬件上。&lt;/p&gt;
&lt;p&gt;但是，这种 6 元的硬件，其 MCU 几乎肯定必然，都是非主流 MCU.&lt;/p&gt;
&lt;p&gt;经过我的一番搜索，我找到了2种可以实现6元控制器的芯片方案。一种是 8051 内核+ foc 协处理器 的 FU6832, 还有一种是 arm 核的 EG6832。&lt;/p&gt;</description>
    </item>
    <item>
      <title>PCB和芯片</title>
      <link>https://microcai.org/2024/01/02/pcb-and-ic-manufactoring.html</link>
      <pubDate>Tue, 02 Jan 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/01/02/pcb-and-ic-manufactoring.html</guid>
      <description>&lt;p&gt;进来做变频器，画了不少 PCB 板子。突然发现画 PCB 和芯片设计，有极大的共同点。&lt;/p&gt;
&lt;h1 id=&#34;先说走线和分层&#34;&gt;先说走线和分层&lt;/h1&gt;
&lt;p&gt;现时 PCB 上的元件，主要以表面贴片为主。元件浮于PCB表面。特别是，我为了节约打样成本，使用的都是单面贴片工艺。更像芯片了。元件只集中于pcb的一个表面。然后线路在 pcb 和 pcb 的另一面。&lt;/p&gt;
&lt;p&gt;如果把电路板倒过来，让贴片元件朝下当“底面”，那就是 元件为底层，上层为走线层。&lt;/p&gt;
&lt;p&gt;这和 IC 的情况是极其相似的。集成电路里，蚀刻法制作的元件，都处于硅的表面。然后是十数层走线层。拿单面贴片的4层板举例，就分了元件层，和4个走线层。&lt;/p&gt;
&lt;h1 id=&#34;接着说封装&#34;&gt;接着说封装&lt;/h1&gt;
&lt;p&gt;在 PCB 上放置一个元件的时候，EDA 并不清楚元件的内部走线。EDA 要做的是，在 PCB 上留下一个“区域” 放置这个元件，以及连接这个元件的若干“焊盘”。&lt;/p&gt;
&lt;p&gt;在 IC 设计领域，也有常说的 “硬IP核”。硬IP核在 EDA 里，也是一个固定大小的，内部情况不透明的“区域”，以及连接这个IP核的若干“输入输出”。&lt;/p&gt;
&lt;p&gt;甚至。连最基础的“MOSFET”，在芯片的 EDA 里，其实也是“封装”。设计者只能选择将这个 MOSFET 放置此处。有3个引脚。但是，这个 MOSFET 的内部结构，是看不到的。这个和在 PCB 上放置最普通的贴片MOS的情况是一模一样的。&lt;/p&gt;
&lt;p&gt;在 PCB 的  EDA 软件里，各种元件都有“封装”，而在芯片的EDA软件里，各种元件，也有封装。
设计pcb既可以选择分立元件，也可以使用各种IC。放在芯片设计领域，就是既可以选择软IP也可以选择硬IP。&lt;/p&gt;
&lt;p&gt;软IP, 在，PCB的 EDA软件里，叫“原理图库”。画原理图的时候可以直接引用。但是转PCB的时候，会把原理图里引入的各种元件引入，你可以重新安排内部元件。而且还可以随时修改原理图。&lt;/p&gt;
&lt;p&gt;在芯片EDA里，软IP, 也不再是一个裸晶上占用固定位置的“封装”，而是会和你自己写的代码一起编译。&lt;/p&gt;
&lt;h1 id=&#34;接着说原理图&#34;&gt;接着说原理图&lt;/h1&gt;
&lt;p&gt;要画 PCB， 先出原理图。原理图上记录里的是 PCB 的原理电路。而芯片，也就集成电路，其实和印刷电路是一回事。只不过一个是毫米级工艺，一个是纳米级工艺。&lt;/p&gt;
&lt;p&gt;既是电路，一样要原理图。&lt;/p&gt;
&lt;p&gt;但是，芯片和 pcb 的最大区别，不是工艺，而是规模。&lt;/p&gt;
&lt;p&gt;一个PCB上，有数百元件，已经算复杂了。&lt;/p&gt;
&lt;p&gt;但是一个芯片，百万元件都是小打小闹。如今最尖端的芯片，上有百亿元件。&lt;/p&gt;
&lt;p&gt;PCB尚可以手绘。设计集成电路，绝无手绘的可能。&lt;/p&gt;
&lt;p&gt;因此，PCB的原理图，可以是一个电路图。
但是，芯片的原理图，就绝无可能是一个电路图。可以说，这个电路图，只能是某种更合适的描述方法的中间产物。&lt;/p&gt;
&lt;p&gt;这个更何时的描述方法，就叫硬件设计语言。而且要经过两次编译转换，才能转换为如pcb那样的原理图。而且这个原理图，无法为人所读。&lt;/p&gt;
&lt;p&gt;硬件设计语言，描述的是硬件的逻辑功能。经过编译器编译后，转变为能实现这个逻辑功能的“门电路”。门电路，是数字电路的基础。正如模拟电路的基础是运放。
但是，不管是门电路还是运放，都不是单一基础元件能实现的。实现一个门电路，需要数个nmos和pmos组成。因为电路里既有nmos又有pmos, 所以又称为互补mos。这也是 CMOS 名称的由来。&lt;/p&gt;</description>
    </item>
    <item>
      <title>三相的恒功率优势</title>
      <link>https://microcai.org/2023/12/27/3pharse-talk-again.html</link>
      <pubDate>Wed, 27 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/27/3pharse-talk-again.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2022/02/14/ev-charging-and-3phase-balance.html&#34;&gt;这篇&lt;/a&gt; 文章里，我曾经说，三相电是恒功率的。&lt;/p&gt;
&lt;p&gt;现在我用一张更直观的图演示这个结论。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;三相的恒功率图&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/3pharse_nice.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;因为电压*电流=功率。所以图片里是使用的纯电阻负载的功率。&lt;/p&gt;
&lt;p&gt;每一相的功率，总是会不断的从 0 到最大，然后从最大到 0.  所以这就是单相电娘胎里带来的劣根性: 每秒钟有100次的功率变化。而且最低是无功率输出。&lt;/p&gt;
&lt;p&gt;但是，如果是三相，情况就发生了变化。虽然每相还是会不断的变化输出功率，但是三者的和却是一个定值。&lt;/p&gt;
&lt;p&gt;如果是电流有一定滞后的负载，比如电机，则这个图片也能说明&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;三相电机的恒功率图&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/3pharse_nice2.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;电流的相位即使滞后，总功率还是恒定的。&lt;/p&gt;
&lt;p&gt;这种总功率恒定的特点，就使得三相电驱动的电机，始终能保持一个恒定的扭矩。
而不会像单相电机那样，扭矩每秒出现100次波动。扭矩每秒出现100次波动，相当与6000转的二冲程发动机的扭矩波动。相当于3000转的4缸发动机的扭矩波动。那是相当的振麻了。&lt;/p&gt;
&lt;p&gt;即使不是电机，也能从恒功率特性中获取优势。
比如，开关电源不再需要一个巨大的储能电容。
当然，一个小容量的滤波电容还是必要的。毕竟需要滤除 pwm 导致的高频谐波。&lt;/p&gt;
&lt;p&gt;&amp;ndash; 更新&lt;/p&gt;
&lt;p&gt;弄了个视频来展示三相恒功率和单相脉动功率导致的电机扭矩差异&lt;/p&gt;
&lt;iframe src=&#34;//player.bilibili.com/player.html?bvid=BV1Fc4118794&amp;page=1&#34; scrolling=&#34;no&#34; border=&#34;0&#34; frameborder=&#34;no&#34; framespacing=&#34;0&#34; allowfullscreen=&#34;true&#34;&gt; &lt;/iframe&gt;</description>
    </item>
    <item>
      <title>foc速成班</title>
      <link>https://microcai.org/2023/12/22/clarke-transform-is-not-essential.html</link>
      <pubDate>Fri, 22 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/22/clarke-transform-is-not-essential.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;在我开始研究 foc 的时候，所有的书籍都在介绍 park 变换和 clarke 变换。有一种魔力告诉你，没这俩变换，就写不成 foc.&lt;/p&gt;
&lt;p&gt;然而事实的真相并不是如此。&lt;/p&gt;
&lt;h2 id=&#34;foc-要控制什么&#34;&gt;foc 要控制什么&lt;/h2&gt;
&lt;p&gt;首先得了解，在 foc 发明前，电机是如何控制的？ foc 发明以前，无刷电机采取的是六步换向法。电机每旋转60度，控制器就要进行一次“电子换向”。控制器输出的，是同一时刻
只有2条线有输出的方波。&lt;/p&gt;
&lt;p&gt;由此，在方波时代，电机控制器要控制的无非就是方波的电压。&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;真的是这样的吗？&lt;/p&gt;
&lt;p&gt;事实上，经常玩航模的童鞋就知道。航模的电调，有一个参数叫“换向提前角”。电调会在本不是换向的时间提前换向。&lt;em&gt;这个提前的时间点，从时间上来说自然是和转速有关。从角度上来说，就和转速无关了。所以叫提前角，而不是提前时间。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;为何要提前换向呢？转子还没到该换向的位置，为何要提前换向呢？&lt;/p&gt;
&lt;p&gt;如果这个问题没有搞明白，是无法理解 foc 的。&lt;/p&gt;
&lt;p&gt;foc 之所以需要电流采样，本质上就是为了确定提前换向角。而不是像航模的电调那样还得人工配置。&lt;/p&gt;
&lt;p&gt;为啥要提前换向呢？&lt;/p&gt;
&lt;p&gt;因为磁场是电流建立的，不是电压建立的。而绕组是一个电感。电感的电流会滞后电压。准时换向，不过是让电压和转子呈 90度角度。而电流滞后，会导致电流并不和转子呈90度，也就是磁场没有和转子呈90度夹角，也就是扭矩没有最大化发挥。&lt;/p&gt;
&lt;p&gt;要最大化发挥电机的扭矩，要磁场垂直于转子，电压就必须有一定的提前量。这个提前量，就只能通过对电流的采样获取。&lt;/p&gt;
&lt;p&gt;所以， foc 的目的，就是让定子磁场垂直于转子磁场。而电流的采样，就是为了获得电流对电压的滞后角，从而对电压角进行提前。&lt;/p&gt;
&lt;h1 id=&#34;前人为啥要进行-parkclark-变换&#34;&gt;前人为啥要进行 park/clark 变换&lt;/h1&gt;
&lt;p&gt;教材上说，是为了将三相变两相。因为两相少一个变量，好控制。&lt;/p&gt;
&lt;p&gt;其实那都是教材不懂装懂瞎说的。三相电流本来就只有2个属性。幅值和相位。这个幅值，说的是他完整周期内的最大值。&lt;/p&gt;
&lt;p&gt;但是，最大值，一个周期里只出现2次。也就是说，在某个采样的瞬间，你拿到的，大概率都只是中间的某个值。难道要连续采样一个完整周期才才能确定最大值吗？&lt;/p&gt;
&lt;p&gt;不能。&lt;/p&gt;
&lt;p&gt;那如何能在采样的瞬间，就能直接知晓最大值和相位呢？&lt;/p&gt;
&lt;p&gt;前人的答案之一，就是 逆 clark 变换 + 逆 park 变换。&lt;/p&gt;
&lt;h2 id=&#34;三相坐标系里的角度描述很困难&#34;&gt;三相坐标系里的角度描述很困难&lt;/h2&gt;
&lt;p&gt;因为我们的数学工具，对角度的描述，是在平面直角坐标系里的。三相电，其实是在平面三维坐标系里的。如果你有数学工具可以直接在这种平面三维坐标系里工作，那就不需要进行变换。&lt;/p&gt;
&lt;p&gt;但是，如果我们将这个变换，限定在一个模块呢？ 只限定在电流采样模块。&lt;/p&gt;
&lt;p&gt;电流采样模块，只对上层输出两个参数， 电流的交流幅值，和当前的相位角。&lt;/p&gt;
&lt;p&gt;那么，整个电机的控制代码，就不会再有任何一个地方需要 park/clark 变换. 而且电流采样那边，只进行一次反clarke 变换。而这个反 clarke 变换，就只是三相瞬时电流转幅值+相角描述的一个转换。&lt;/p&gt;
&lt;p&gt;那么整个电机控制流程逻辑，就会变得异常清晰明白。不会有反直觉的变换掺杂其中。&lt;/p&gt;
&lt;p&gt;甚至，电流采样是 foc 达到最大效率的一个手段。没有电流采样，不过是效率不能最佳化。所以这个电流采样甚至不是初期必修课。&lt;/p&gt;
&lt;h2 id=&#34;所以前人是为了自己软件工程上的考虑&#34;&gt;所以前人是为了自己软件工程上的考虑&lt;/h2&gt;
&lt;p&gt;前人是为自己软件实现方便上的考虑。既然电流采样这边是必须要进行变换。否则无法获得电流相角。那就索性其他地方也全部改成二维坐标系。
而前人的这个决定，被后人东施效颦，只敢模仿，不敢超越。&lt;/p&gt;</description>
    </item>
    <item>
      <title>变频器制作-第九部分之ESP32C3 也能输出svpwm</title>
      <link>https://microcai.org/2023/12/20/esp32c3-can-drive-svpwm.html</link>
      <pubDate>Wed, 20 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/20/esp32c3-can-drive-svpwm.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;先看以下乐馨官方的 ESP32S3 和 ESP32C3 的对比&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/esp32s3-vs-esp32c3.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;很明显，ESP32C3 缺乏 MCPWM 设备。&lt;/p&gt;
&lt;p&gt;所谓 MCPWM, 就是专门为产生svpwm设计的电路。他能产生6路互补的PWM信号，并且实现中央对齐。然后还能实现在PWM信号的特定位置产生同步事件。app据此可以在这个同步事件上实现电流采样。&lt;/p&gt;
&lt;p&gt;一度我以为 ESP32C3 是无法用于驱动电机的。&lt;/p&gt;
&lt;p&gt;直到一次偶然，我看到 SimpleFOC 的论坛里有人提到要支持 ESP32C3。我在想，这C3不是没MCPWM么？ SimpleFOC咋支持？&lt;/p&gt;
&lt;p&gt;事实是，SimpleFOC 也确实不支持 C3。但是有人回复他实现过。就用的 LEDC PWM。&lt;/p&gt;
&lt;p&gt;要知道，ESP32C3 可比 S3 便宜了一半还多。要真的能驱动电机，那我的 VVVF 变频器大业，又多了一项可选的MCU！&lt;/p&gt;
&lt;h1 id=&#34;实践&#34;&gt;实践&lt;/h1&gt;
&lt;p&gt;虽然别人有提过他用 LEDC PWM 实现了 foc。但是吧，无代码无真相。但是总归人家说可以。那我研究研究吧。于是购入 ESP32S3。&lt;/p&gt;
&lt;p&gt;等等，不是说C3吗？咋买了S3呢？因为我确信我的VVVF需要蓝牙！需要WIFI！AT32F415已经不能满足我的需求了。&lt;/p&gt;
&lt;p&gt;然后顺便买了个9.9的 ESP32C3开发板。&lt;/p&gt;
&lt;p&gt;等开发板到了，我马上研究起了 ESP32C3。虽然C3是顺便买的，但是不妨碍我先研究它。&lt;/p&gt;
&lt;p&gt;于是在项目里创建了 lib/libvfd/hal/esp32c3pwm.{hpp,cpp} 文件。&lt;/p&gt;
&lt;p&gt;着手研究 ESP32C3 里的 LEDC PWM。&lt;/p&gt;
&lt;p&gt;最后踩了无数的坑后，把他实现出来了。&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;
#if defined(ESP_PLATFORM)

#ifdef CONFIG_IDF_TARGET_ESP32C3

#include &amp;#34;esp32c3pwm.hpp&amp;#34;
#include &amp;#34;driver/ledc.h&amp;#34;
#include &amp;#34;esp_err.h&amp;#34;
#include &amp;#34;esp_timer.h&amp;#34;
#include &amp;#34;freertos/FreeRTOS.h&amp;#34;
#include &amp;#34;freertos/task.h&amp;#34;
#include &amp;#34;freertos/timers.h&amp;#34;
#include &amp;#34;private/commons.hpp&amp;#34;

#include &amp;#34;os/os.hpp&amp;#34;

#define FOC_MCPWM_TIMER_RESOLUTION_HZ 40000000 // 40MHz, 1 tick = 0.025us

#ifndef INVERT_LOW_SIDE
#define INVERT_LOW_SIDE 0
#endif

const static char* TAG = &amp;#34;vfd&amp;#34;;

namespace motorlib
{
	struct esp32c3pwmdriver_impl
	{
		/*
		 * Prepare and set configuration of timers
		 * that will be used by LED Controller
		 */
		ledc_timer_config_t timer_config = {
			.speed_mode		 = LEDC_LOW_SPEED_MODE, // timer mode
			.duty_resolution = LEDC_TIMER_13_BIT,	// resolution of PWM duty
			.timer_num		 = LEDC_TIMER_0,		// timer index
			.freq_hz		 = 4000,				// frequency of PWM signal
			.clk_cfg		 = LEDC_AUTO_CLK,		// Auto select the source clock
		};

		int gen_gpios[6]; // 3 GPIO pins for generator config

		// hardware variables
		int pwm_frequency;
		int pwm_period;

		esp32c3pwmdriver_impl(
			int pin_AH, int pin_AL, int pin_BH, int pin_BL, int pin_CH, int pin_CL, int PWM_freq)
			: pwm_frequency(PWM_freq)
		{
			gen_gpios[0] = pin_AH;
			gen_gpios[1] = pin_BH;
			gen_gpios[2] = pin_CH;
			gen_gpios[3] = pin_AL;
			gen_gpios[4] = pin_BL;
			gen_gpios[5] = pin_CL;

			// ledc_timer_config.duty_resolution = ledc_find_suitable_duty_resolution(LEDC_USE_XTAL_CLK, pwm_frequency);

			pwm_period = 1 &amp;lt;&amp;lt; timer_config.duty_resolution;
			// pwm_frequency = timer_config.freq_hz;

			esp_err_t ret;
			ledc_timer_rst(LEDC_LOW_SPEED_MODE, LEDC_TIMER_0);

			ret = ledc_timer_config(&amp;amp;timer_config);
			timer_config.timer_num = LEDC_TIMER_1;
			ret = ledc_timer_config(&amp;amp;timer_config);
			os::printf(&amp;#34;ledc_channel_config return %d\n&amp;#34;, ret);

			ledc_channel_config_t ledc_channel[] = {
				{
					.gpio_num	= pin_AH,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_0,
					.timer_sel	= LEDC_TIMER_0,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = 0 },
				},
				{
					.gpio_num	= pin_BH,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_1,
					.timer_sel	= LEDC_TIMER_0,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = 0 },
				},
				{
					.gpio_num	= pin_CH,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_2,
					.timer_sel	= LEDC_TIMER_0,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = 0 },
				},
				{ .gpio_num		= pin_AL,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_3,
					.timer_sel	= LEDC_TIMER_1,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = !INVERT_LOW_SIDE } },
				{ .gpio_num		= pin_BL,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_4,
					.timer_sel	= LEDC_TIMER_1,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = !INVERT_LOW_SIDE } },
				{ .gpio_num		= pin_CL,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_5,
					.timer_sel	= LEDC_TIMER_1,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = !INVERT_LOW_SIDE } },
			};

			for (int ch = 0; ch &amp;lt; 6; ch++)
			{
				ret = ledc_channel_config(&amp;amp;ledc_channel[ch]);
				os::printf(&amp;#34;ledc_channel_config return %d\n&amp;#34;, ret);
			}

			stop();
		}

		void set_duty(float_number U_a, float_number U_b, float_number U_c)
		{
			auto u_lpoint = clamp&amp;lt;int&amp;gt;(U_a * pwm_period, 0, pwm_period-1);
			auto v_lpoint = clamp&amp;lt;int&amp;gt;(U_b * pwm_period, 0, pwm_period-1);
			auto w_lpoint = clamp&amp;lt;int&amp;gt;(U_c * pwm_period, 0, pwm_period-1);

			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, u_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, v_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_2, w_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_3, u_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_4, v_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_5, w_duty);

			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_2);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_3);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_4);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_5);
		}

		void set_frequency(int freq)
		{
			if (freq &amp;lt;= 6000 &amp;amp;&amp;amp; freq &amp;gt;= 3000)
			{
				ledc_set_freq(LEDC_LOW_SPEED_MODE, LEDC_TIMER_0, freq);
				ledc_set_freq(LEDC_LOW_SPEED_MODE, LEDC_TIMER_1, freq);
				pwm_frequency = freq;
                esp_timer_restart(hr_timer, 1000000/freq);
			}
		}

		void stop()
		{
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_2, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_3, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_4, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_5, 0);
		}

		void start() { }

		int get_frequency() { return pwm_frequency; }

		pwmdriver::timer_fn pwm_cb;

		static void timer_cb(void* user_data)
		{
			auto _this = reinterpret_cast&amp;lt;esp32c3pwmdriver_impl*&amp;gt;(user_data);_this-&amp;gt;pwm_cb(_this-&amp;gt;pwm_frequency);
		}

		esp_timer_handle_t hr_timer;

		void link_timer(pwmdriver::timer_fn fn)
		{
			pwm_cb = fn;

			esp_timer_create_args_t timer_arg = {
				.callback			   = timer_cb,
				.arg				   = this,
				.dispatch_method	   = ESP_TIMER_TASK,
				.name				   = &amp;#34;pwm_tmr&amp;#34;,
				.skip_unhandled_events = true,
			};

			esp_timer_create(&amp;amp;timer_arg, &amp;amp;hr_timer);
			// 200us = 5khz pwm
			esp_timer_start_periodic(hr_timer, 200);
		}

        ~esp32c3pwmdriver_impl()
        {
            esp_timer_stop(hr_timer);
			esp_timer_delete(hr_timer);
        }
	};

	//////////////////////////////////////////////////////////////////////////////
	esp32c3pwmdriver::esp32c3pwmdriver(
		int pin_AH, int pin_AL, int pin_BH, int pin_BL, int pin_CH, int pin_CL)
	{
		impl = new esp32c3pwmdriver_impl(pin_AH, pin_AL, pin_BH, pin_BL, pin_CH, pin_CL, 4000);
	}

	esp32c3pwmdriver::~esp32c3pwmdriver()
	{
        delete impl;
    }

	// Function setting the duty cycle to the pwm pin (ex. analogWrite())
	// - BLDC driver - 6PWM setting
	// - hardware specific
	void esp32c3pwmdriver::set_duty(float_number U_a, float_number U_b, float_number U_c)
	{
		impl-&amp;gt;set_duty(U_a, U_b, U_c);
	}

	void esp32c3pwmdriver::start() { impl-&amp;gt;start(); }

	void esp32c3pwmdriver::stop() { impl-&amp;gt;stop(); }

	int esp32c3pwmdriver::get_frequency() { return impl-&amp;gt;get_frequency(); }

	void esp32c3pwmdriver::set_frequency(int f) { impl-&amp;gt;set_frequency(f); }

	void esp32c3pwmdriver::link_timer(timer_fn fn) { impl-&amp;gt;link_timer(fn); }

}

#endif // CONFIG_IDF_TARGET_ESP32C3
#endif // defined(ESP_PLATFORM)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;不同于其他平台使用 PWM 自身的定时器中断，esp32c3 上，pwm 周期更新的回调是由一个高精度定时器回调提供的。之所以不用 pwm 的回调，是因为 ledc pwm 并不会产生这样的中断——除非使用了硬件fade功能。
但电机控制岂是fade能瞎fade的？&lt;/p&gt;</description>
    </item>
    <item>
      <title>标准库 sin 之错</title>
      <link>https://microcai.org/2023/12/19/why-sin-is-wrong.html</link>
      <pubDate>Tue, 19 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/19/why-sin-is-wrong.html</guid>
      <description>&lt;h1 id=&#34;标准库-sin&#34;&gt;标准库 sin()&lt;/h1&gt;
&lt;p&gt;在 C 语言里，有一个计算三角函数的函数， sin() , 其定义为 &lt;code&gt;double sin(double)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;由于 sin 的结果大概率为无理数，所以使用 浮点数为参数也未尝不可。&lt;/p&gt;
&lt;p&gt;但，我要说但是了。&lt;/p&gt;
&lt;p&gt;在工业界，不管是土木工程还是机械制造，我们都倾向于使用“角度”而不是”弧度“。&lt;/p&gt;
&lt;h1 id=&#34;转换一下很困难&#34;&gt;转换一下很困难？&lt;/h1&gt;
&lt;p&gt;如果所有的程序都在干角度转弧度这件事，那只能说明库错了。库逼迫大家用弧度，而实际上大家用角度。&lt;/p&gt;
&lt;p&gt;看下 180/pi 这个常数的定义这各大软件里有多普遍。就知道实际上大家都这用角度存储。只是这需要 sin 值的时候再转弧度调用 sin。
因为 sin 本身是一个开销很大的操作，所以很多程序员只是觉得多了一个乘法，并没有意识到 sin 的接口定义错了。&lt;/p&gt;
&lt;h1 id=&#34;为何应该用角度&#34;&gt;为何应该用角度？&lt;/h1&gt;
&lt;p&gt;因为常用角度是整数。在计算机里，弧度无法精确的表达90度，45度，30度，和60度。这都是最常用的角度。
而无法精确表达就要取近似。取近似就要丢精度。&lt;/p&gt;
&lt;p&gt;而精度误差是可以累积的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第八部分</title>
      <link>https://microcai.org/2023/12/16/sync-modulation-corrected.html</link>
      <pubDate>Sat, 16 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/16/sync-modulation-corrected.html</guid>
      <description>&lt;h1 id=&#34;载波比得多少合适&#34;&gt;载波比得多少合适&lt;/h1&gt;
&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2023/12/05/sync-pwm-async-pwm.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我讲解了同步调制和异步调制。&lt;/p&gt;
&lt;p&gt;那时候，实现的同步调制是有问题的。主要在同步调制在载波比的计算上出了问题。&lt;/p&gt;
&lt;p&gt;原来的想法是，载波比是要能被3整除。同时还得是奇数。&lt;/p&gt;
&lt;p&gt;其实这个公式说的是，正弦波半周上的 pwm 波的数量，得是能被3整除。同时还得是奇数。
也就是说，其实整个周期的载波比，是能同时被6整除. 同时还得是2的奇数倍。&lt;/p&gt;
&lt;p&gt;于是发现了代码中的错误。进行了修正。&lt;/p&gt;
&lt;p&gt;虽然实际上靠听觉并不能发现电机的声音有任何变化。。。。。。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;正弦波pwm&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/spwm.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;在同步调制里，正弦波的频率变高。但是， 每个正弦波所包含的 pwm 方波的个数是维持不变的。而且 pwm 方波的个数，在每个半周里，必须是奇数。
这样 pwm 占空比最大的那个位置，正好对应 正弦值最大的时刻。
这样的谐波是最小的。&lt;/p&gt;
&lt;p&gt;如上图所示， 每个半周里，有5个 pwm 波。整个周期里，一共是10个 pwm。所以载波比为 10。 而 10 正好是 2 的奇数倍。&lt;/p&gt;
&lt;p&gt;而这，只是对单相正弦信号输出的要求。&lt;/p&gt;
&lt;p&gt;如果要输出三相对称正弦波信号，则载波比N，还必须同时满足能被3整除。 这样每个相的正弦波，也都在 pwm 波开始的时间里，保持对称。&lt;/p&gt;
&lt;p&gt;因为 10 不能被3整除&lt;/p&gt;
&lt;p&gt;所以要再向后找  14， 18 . 于是第一个满足这个要求的载波比是 18&lt;/p&gt;
&lt;p&gt;然后接下来，每个满足的载波比数，都依次比上一次多 12&lt;/p&gt;
&lt;p&gt;18 30 42 54&lt;/p&gt;
&lt;p&gt;之前的代码就是这个地方计算错了。&lt;/p&gt;
&lt;p&gt;今天改进了这个。把载波比计算终于正确了。&lt;/p&gt;
&lt;p&gt;错误的载波比，并没用起到同步调制减少谐波的优势。还不如实现起来更简单的异步调制。&lt;/p&gt;
&lt;h1 id=&#34;载波和基波的相位同步&#34;&gt;载波和基波的相位同步&lt;/h1&gt;
&lt;p&gt;除了载波比的计算要正确。载波的相位还得和基波同步。才能保证载波pwm占空比最大的那个地方，恰好也对应于 sin 值最大的地方。&lt;/p&gt;
&lt;p&gt;只要有一次，基波和载波的相位对上，则在下一次动载波比之前，就能一直维持住同步。&lt;/p&gt;
&lt;p&gt;也就是说，进行相位对齐的时机，是在修改载波比的时候。&lt;/p&gt;
&lt;p&gt;为了让输出波形不会突变到和载波对齐。在修改载波比的时候，要进行一段时间的异步调制。然后让载波和基波频率对上后。切换为同步调制。&lt;/p&gt;
&lt;p&gt;在异步调制的时候，随时监控基波和载波的相位差，追平的时候，立刻切换为同步调制。&lt;/p&gt;
&lt;p&gt;一旦进入同步调制。计算占空比的代码其实会非常简单。
因为同步调制下，占空比是周期变化并且固定的。而且是固定的几个数值。&lt;/p&gt;
&lt;p&gt;为何之前说，同步调制的代码更复杂。这里又说，一旦进入同步调制，计算占空比的代码会非常简单呢？&lt;/p&gt;
&lt;p&gt;因为同步调制的代码是逻辑复杂。要进行“换挡” 操作。换挡后还要进行同步。&lt;/p&gt;</description>
    </item>
    <item>
      <title>单片机的行业怪病</title>
      <link>https://microcai.org/2023/12/11/mcu-industry-myth.html</link>
      <pubDate>Mon, 11 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/11/mcu-industry-myth.html</guid>
      <description>&lt;h1 id=&#34;从单片机的存储空间说起&#34;&gt;从单片机的存储空间说起&lt;/h1&gt;
&lt;p&gt;别说市面上没有几百家也与几十家的单片机品牌。就是同一个单片机厂家，其单片机型号也是十分繁多的。&lt;/p&gt;
&lt;p&gt;这些名目繁多的单片机型号，归根结底，是 核心性能，存储容量，和封装引脚 数量的排列组合。&lt;/p&gt;
&lt;p&gt;其中，存储容量是极为关键的区分价格的因子。核心性能，都会划分为 低性能，主流性能，高性能。存储容量也会分成小容量，中容量，大容量，超大容量。&lt;/p&gt;
&lt;p&gt;但是，即使是低端低性能单片机，如果搭配的是个大容量乃至超大容量的存储空间，售价一样就会高高在上，超过高性能小容量的单片机。&lt;/p&gt;
&lt;p&gt;而仔细品味品味不同容量之间的售价差距会发现，单片机的存储空间，是按每 KB 多少块钱算的。&lt;/p&gt;
&lt;p&gt;在 PC 行业，一块钱已经可以买到数个GB存储容量的当下，单片机还将 KB 卖到数元的高价。存储容量的价格差距达到百万倍以上。&lt;/p&gt;
&lt;h1 id=&#34;不思进取的单片机业界&#34;&gt;不思进取的单片机业界&lt;/h1&gt;
&lt;p&gt;老中医曾经说过，如果现在还要造 8GB 容量的机械硬盘，其成本并不会比 8TB 的低多少。所以，如果因为某些特殊原因，实在用不上超过 8GB 的存储空间，
使用PC进行项目开发的公司，依旧会选择1TB或者2TB的硬盘容量。并不是因为他需要那么大，而是因为当下这么大的最便宜。&lt;/p&gt;
&lt;p&gt;但是，在单片机这个行业，情况发生了不一样的变化。如果你能够把你的代码裁剪到 8KB 大小，单片机厂就敢造 8KB 容量的单片机。
虽然他造8MB的成本和8KB并没有太大的区别。但是因为业界用不到8MB,他就会继续按8KB的目标市场造。并且为16KB的容量收取额外的溢价。&lt;/p&gt;
&lt;p&gt;而单片机市场的受众，也被这种吃老本的源头所驯化。特别在意代码的裁剪。于是二者是相互成就。一直压着单片机的容量。在30年的时间里，单片机的主流容量，只从 8KB 增长到了 128KB。 增加不过 8 倍。&lt;/p&gt;
&lt;p&gt;而同期的 PC ，存储容量则从 1.44MB 暴涨到 8TB。增长超过五千万倍。&lt;/p&gt;
&lt;p&gt;整个单片机业界陷入一终迟滞。不仅仅厂家喜欢躺着吃老本。顾客也要求厂家吃老本。&lt;/p&gt;
&lt;p&gt;曾经有人说，某单片机厂家非常良心。一款单片机卖了十几年还在供货，而且没涨价。他是想跨人家供货周期长，对自己的项目后续供应有保障。还夸人家十几年不涨价，保障了用户的利益。&lt;/p&gt;
&lt;p&gt;我的天，如果 intel 现在还在按同样的价格卖 80386, 不知道他还会不会夸 intel 业界良心。&lt;/p&gt;
&lt;p&gt;但是即使是同一个人, 他还是会骂 intel 是牙膏厂的.&lt;/p&gt;
&lt;p&gt;那么为何会这样呢?&lt;/p&gt;
&lt;h1 id=&#34;还是代码出了问题&#34;&gt;还是代码出了问题&lt;/h1&gt;
&lt;p&gt;按理说, 顾客是不喜欢吃老本的商家的. 谁都希望花同样的钱买到的东西越来越好. 但是单片机程序员为何是个例外?&lt;/p&gt;
&lt;p&gt;因为, 如果老款停产了,新款性能再好, 对单片机程序员来说都是没有用的.因为他的代码跑不了.&lt;/p&gt;
&lt;p&gt;单片机的程序都是为特定的单片机完全适配开发的. 单片机不仅不能升级增加功能, 连完全不增加新功能只是单纯的提高主频, 都是不可以的. 因为单片机代码里大量的 delay() 函数已经写死了主频. 更换主频就会导致 delay 时间变短. 于是原来设计好的逻辑就无法正常运行了.&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第七部分</title>
      <link>https://microcai.org/2023/12/09/dig-into-burnned-motor.html</link>
      <pubDate>Sat, 09 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/09/dig-into-burnned-motor.html</guid>
      <description>&lt;h1 id=&#34;从第一次烧变频器说起&#34;&gt;从第一次烧变频器说起&lt;/h1&gt;
&lt;p&gt;第一次烧变频器，也是第一次绕电机。&lt;/p&gt;
&lt;p&gt;由于没有供实验用的小功率低压异步电机。所以只能买一个现有的，利用它的外壳，转子，定子。而替换掉它
的线圈。不就可以了？&lt;/p&gt;
&lt;p&gt;于是说干就干。买了一个落地扇电机。主要是他小，而且便宜。糟蹋了不心疼。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;电风扇电机&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/1pharse-motor.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;然后&lt;/p&gt;
&lt;p&gt;拆！&lt;/p&gt;
&lt;p&gt;绕好后的效果就是这样&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;绕好的效果&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/my_motor.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;然后，绕好的视频演示&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://www.bilibili.com/video/BV1mg4y1o7rF/&#34;&gt;BV1mg4y1o7rF&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;然后，mos管就烧了。&lt;/p&gt;
&lt;h1 id=&#34;研究问题根源&#34;&gt;研究问题根源&lt;/h1&gt;
&lt;p&gt;一开始我认为是电流过大（废话），降低电压，提高频率，自然就把电流降下来了。&lt;/p&gt;
&lt;p&gt;但是电流降下来了，扭矩也没了。&lt;/p&gt;
&lt;p&gt;要想电机还有扭矩，绕组就必须有一定的电流。这个电流还远大于变频器从电源吸收的电流。&lt;/p&gt;
&lt;p&gt;因为这部分电流，就是在绕组里内部循环。也就是所谓的“无功功率”。&lt;/p&gt;
&lt;p&gt;这个电流必须足够大，才能让转子产生足够的感应磁场。
所以这部分电流，又叫 励磁电流。&lt;/p&gt;
&lt;p&gt;感应电机的特点就是，运行电流基本上由励磁电流构成。&lt;/p&gt;
&lt;p&gt;我自己绕的这个电机，在烧掉 mos 前，我观察到的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 变频器输出电压较低的时候，绕组电流不足 3A, 电机无法运转。
2. 变频器输出足够电压，绕组电流超过 3A. 电机开始运转。此时变频器只从电源吸收0.3A电流。
3. 增加变频器的输出，变频器吸收电流到 2A, 此时绕组电流依旧是 3A 略多。
4. 继续加码，变频器吸收电流开始和绕组电流几乎相同。开始接近 4A.
5. 然后。。mos 冒烟。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其实虽然变频器以30w 以上功率只运行了十几秒。但是其实 mos 以超过 3A 电流运行时间已经超过一分钟有余了。&lt;/p&gt;
&lt;p&gt;我回看了一下电路设计图，发现我居然选了个耐压 100V ，过流能力才 9A 的 mos 。。 脑子瓦特了。应该选 60V/30A 的。当时画图的时候肯定没好好选mos.&lt;/p&gt;
&lt;p&gt;因为 9A 电流是持续电流。需要 mos 工作在持续导通状态。 如果工作在开关状态。有开关损耗。实际 mos 能过的电流只有一半。约 4.5A. 但是那还是在加散热片的情况下。我这没加散热片裸跑的 mos ，超过 3A 的电流跑了数分钟，也该烧。&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第六部分</title>
      <link>https://microcai.org/2023/12/08/cooperative-multitasking-in-mcu.html</link>
      <pubDate>Fri, 08 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/08/cooperative-multitasking-in-mcu.html</guid>
      <description>&lt;h1 id=&#34;从多任务说起&#34;&gt;从多任务说起.&lt;/h1&gt;
&lt;p&gt;前序日子，都在进行核心代码的开发。终于最近进入了 UI 界面的开发了。&lt;/p&gt;
&lt;p&gt;虽然叫 UI, 但是其实并没有窗口。也没有命令行。&lt;/p&gt;
&lt;p&gt;而是几个 LED 灯 + 一个旋钮 + 一个红外遥控器。&lt;/p&gt;
&lt;p&gt;这些也算是能和用户交互了，所以，算UI没什么问题吧？&lt;/p&gt;
&lt;p&gt;一旦进入 UI 的开发领域，马上就遇到单片机的一个掣肘了：
没有操作系统。&lt;/p&gt;
&lt;p&gt;为什么UI需要操作系统呢？&lt;/p&gt;
&lt;p&gt;因为 UI 是由多个子任务构成的。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;vvvf图解&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/vvvf_block_diagram.svg&#34;&gt;&lt;/p&gt;
&lt;p&gt;libvfd 里， SVPWM 的生成是受时钟中断驱动的。&lt;/p&gt;
&lt;p&gt;但是，V/F 控制，则是一个独立的循环。V/F 控制，收到外部的控制请求后，
会根据电机的加减速特性，来逐步的提高 svpwm 模块的电压和频率。&lt;/p&gt;
&lt;p&gt;还有，遥控接收，编码器处理。这些代码，都需要自己的一个控制循环。&lt;/p&gt;
&lt;p&gt;也就是意味着，这个变频器的内部，有多个独立的 “控制流”。&lt;/p&gt;
&lt;p&gt;独立的控制流，就是线程。&lt;/p&gt;
&lt;p&gt;但是单片机没有操作系统，如何使用线程呢？&lt;/p&gt;
&lt;h1 id=&#34;用户自己实现的线程&#34;&gt;用户自己实现的线程&lt;/h1&gt;
&lt;p&gt;其实不需要操作系统，用户也可以自己实现“控制流上下文切换”。也就是用户态线程。矣？等等，单片机没有操作系统，更没有用户态和内核态之分。不过也可以借用这个术语嘛。&lt;/p&gt;
&lt;p&gt;那么在单片机里，所谓的用户态线程，指的其实是 c++ 协程。特别是 C++20 的协程。&lt;/p&gt;
&lt;p&gt;其实，在单片机里，所谓协程，主要的上下文切换手段，就是 co_await delay(ms);&lt;/p&gt;
&lt;p&gt;只要当前人物想 sleep 一段时间，就让出 cpu 时间。然后交给协程的列队管理器去调度下一个协程。&lt;/p&gt;
&lt;p&gt;因为协程的运行是不会被抢占的。只能是主动的 delay 放弃。所以，这种多任务的方式，就叫 &lt;strong&gt;协作式多任务&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&#34;实现-yield&#34;&gt;实现 yield&lt;/h2&gt;
&lt;p&gt;目前单片机的编译器版本参差不齐，co_await 对编译器的版本要求太高。
加上 co_await 背后的机制也不容易理解。&lt;/p&gt;
&lt;p&gt;所以，目前我使用的是 asio 作者发明的 stackless coro.&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第五部分</title>
      <link>https://microcai.org/2023/12/05/sync-pwm-async-pwm.html</link>
      <pubDate>Tue, 05 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/05/sync-pwm-async-pwm.html</guid>
      <description>&lt;h1 id=&#34;pwm-调制-正弦波&#34;&gt;pwm 调制 正弦波&lt;/h1&gt;
&lt;p&gt;计算机的世界是一个离散的世界。离散的世界，是用很小的矩形去逼近连续的世界。&lt;/p&gt;
&lt;p&gt;其实傅里叶告诉我们，一切波形都是正弦波的叠加。&lt;/p&gt;
&lt;p&gt;于是 pwm 看起来是方波，但是其实也是正弦波。&lt;/p&gt;
&lt;p&gt;pwm 之所以可以模拟正弦波的效果，就是因为 pwm 可以看成被模拟的正弦波+很多很多的谐波构成。&lt;/p&gt;
&lt;p&gt;而这些多余的谐波，只要这个谐波的频率比正弦波本体大很多，就可以被低通滤波器完美的过滤掉。&lt;/p&gt;
&lt;h1 id=&#34;pwm-频率和-开关损耗&#34;&gt;pwm 频率和 开关损耗&lt;/h1&gt;
&lt;p&gt;pwm 的频率越高，则调制比就越大。所谓调制比，就是pwm的频率和逆变器要输出的正弦波频率的比值。&lt;/p&gt;
&lt;p&gt;理论上来说， pwm 的频率越高，调制比越大，那么经过电机绕组这个大电感后过滤出来的电流，就会越接近完美的正弦波。
也就是电流的谐波就越少。
因为电感对高频的阻碍作用是越来越大的。电机绕组里的电流越接近正弦波，则谐波损失越少。
因为只有基频才能输出机械能。高频的谐波只能变成震动和发热。&lt;/p&gt;
&lt;p&gt;所以，从降低电机的铁损来说，pwm 的频率越高越好。&lt;/p&gt;
&lt;p&gt;但是， pwm 频率太高了，也有一个缺点，就是导致开关损耗增加。
因为 MOS 管不是理想的开关管。即使是理想的开关管，也不能突破物理定律让电流突变。&lt;/p&gt;
&lt;p&gt;MOS管关闭和打开的时候，电流从 最大到0，和从0到最大，中间必然是有一个斜坡的。这个斜坡，意味着加在MOS管两端的电压是持续变化的。于是电压和电流的乘积，会先增加后减少。他们的积分，就是 MOS 管的开关损耗。&lt;/p&gt;
&lt;p&gt;MOS管的开关速度越快，积分就会越少。也就是开关损耗越低。&lt;/p&gt;
&lt;p&gt;这就是为啥要使用氮化镓的由来。&lt;/p&gt;
&lt;p&gt;传统上，使用硅参锗做的晶体管，每一层硅原子的耐压不高。导致 MOS 管要想更高的耐压，其参杂厚度就要增加。
而增加的参杂厚度，必然会降低开关速度。&lt;/p&gt;
&lt;p&gt;也就是 MOS 管的 耐压和开关速度，是个矛盾体。&lt;/p&gt;
&lt;p&gt;耐压 1.5v 的，比如用来构成 CPU 里的门电路的管子，开关速度可以做到数个 GHZ。
但是，耐压到 1500v 的管子，开关速度就只能做到 1khz 了。&lt;/p&gt;
&lt;p&gt;如果把制作材料从硅改为氮化镓，则同样 1500v 耐压，开关速度还可以做到 1Mhz。&lt;/p&gt;
&lt;p&gt;而变频器，始终是需要面对大电压大电流的工况的。而新材料MOS管非常的贵。所以变频器，是不能异想天开的使用一个超高的 pwm 频率。
而是始终要面临开关损耗问题。&lt;/p&gt;
&lt;p&gt;在开关损耗和电机的谐波铁损之间取折衷，于是变频器普遍会使用 1khz - 8khz 的开关频率。而且越是大功率的变频器，开关频率都倾向于比小功率的更低。&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第四部分</title>
      <link>https://microcai.org/2023/12/01/max-power-factor-track.html</link>
      <pubDate>Fri, 01 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/01/max-power-factor-track.html</guid>
      <description>&lt;h1 id=&#34;感应电机的开环控制&#34;&gt;感应电机的开环控制&lt;/h1&gt;
&lt;p&gt;在没有使用变频器的时候，感应电机无法调速。交流电改变频率虽然困难，但是改变电压很容易。
因此也有通过自耦变压器调压后驱动感应电机的方法。&lt;/p&gt;
&lt;p&gt;但是仅仅是降低了电压，扭矩降低导致转差变大。转差变大使得转子发热增加。不利于电机的长期稳定运行。&lt;/p&gt;
&lt;p&gt;所以有了 恒压频比的开环变频调速器。注意，这个词的分词应该是  恒 压频比。&lt;/p&gt;
&lt;p&gt;意思是以固定的 频率和电压的比值进行调速。比如一个额定 220v/50hz 的电机，当试图降一半转速运行的时候，可以设定逆变器输出 110v/25hz 给电机。&lt;/p&gt;
&lt;p&gt;恒压频比是一种开环控制。控制器只是盲目的输出一个设定的电压和频率。但是并不能让电机工作在最佳的特性点上。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;异步电机的机械特性&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/im_torque_characteristics.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;图中，恒坐标是转差率，纵坐标为扭矩。B 点就是电机的最佳工作点。但是电机遇到扰动的时候，很容易进入 B-A 区间。
因此，实际会尽量让电机工作在 B-C 区间，并靠近 B 点。&lt;/p&gt;
&lt;p&gt;Tm 的值表示电机的最大扭矩，电机的最大扭矩正比于电压的平方。&lt;/p&gt;
&lt;p&gt;因此，可以看出，使用恒压频比控制，并不能很好的让电机工作在最佳状态。&lt;/p&gt;
&lt;p&gt;所以就得出了在电动汽车领域更常见的做法：&lt;/p&gt;
&lt;h1 id=&#34;转差率闭环控制&#34;&gt;转差率闭环控制&lt;/h1&gt;
&lt;p&gt;既然电机的最大扭矩取决于电压，那只要知道了电机的转速，控制逆变器输出的频率，让电机始终工作在最大扭矩上。意味着在相同的转速和扭矩输出下（即相同的机械功率输出下）。闭环控制的逆变器始终会比恒压频比的控制器输出更低的电压。于是使得电机吸收的电功率跟小，也就是机械效率更高。&lt;/p&gt;
&lt;p&gt;怎么知道电机的转速呢？&lt;/p&gt;
&lt;p&gt;常规做法，是使用转速传感器。有了转速传感器，就可以进行基于转差率的闭环控制。知道电机转速后，可以立马获得当前输出频率。输出电压设定为 min(恒压频比计算出来的频率, 用户设定的扭矩电压)&lt;/p&gt;
&lt;p&gt;也就是随着转速的提升逐步提高电压，并在达到最大电压后停止电压攀升。如果电机扭矩还有富裕（负载较低）则电机电压不再提升的情况下，频率会继续提升，也就是进入弱磁控制状态。可以榨干电机的机械潜力。&lt;/p&gt;
&lt;p&gt;转差率闭环控制下，异步电机的特性就更贴近于直流电机了。通过调节电压可以轻松的控制扭矩，而频率则通过闭环控制自动跟踪。控制器输出电流频率，正比于电机转速，和同步电机异曲同工之妙。只是不需要控制电流相位。&lt;/p&gt;
&lt;h1 id=&#34;无转速传感器无参数设定的闭环控制&#34;&gt;无转速传感器无参数设定的闭环控制&lt;/h1&gt;
&lt;p&gt;转速传感器不仅仅提高了整个系统的成本，而且降低了电机的可靠性。因为异步电机工作环境通常较为恶劣。也正是因为恶劣环境下必须选择结构较为简单的异步电机。&lt;/p&gt;
&lt;p&gt;所以，如果能使脱离转速传感器，但是依旧使用闭环控制，则能同时兼具开环控制的低成本优势和闭环控制的高效率优势。&lt;/p&gt;
&lt;p&gt;前人提出了不少方式，但是这些方式有一个共同特点：需要异步电机的各项参数。 如绕组电感，绕组电阻，额定转差率。&lt;/p&gt;
&lt;p&gt;事实上，额定转差率是一个更为难获取的数值。其实使用转速传感器进行闭环控制的时候，也需要这个参数。这也是为何闭环控制器，通常和电机绑定。而市面上普遍单独售卖的变频器，都是开环控制。&lt;/p&gt;
&lt;p&gt;因此，如何让变频器可以同直流电机控制器一样，无需设定电机参数，就能自动获得和直流电机一样（或者接近）的控制特性呢？&lt;/p&gt;
&lt;p&gt;于是，经过我长期的思考，我得出了一个解决方案：&lt;/p&gt;
&lt;h2 id=&#34;最大功率因素点跟踪&#34;&gt;最大功率因素点跟踪&lt;/h2&gt;
&lt;p&gt;交流电机在运行过程中，不同的运转状态下，会产生不同的功率因素。&lt;/p&gt;
&lt;p&gt;例如，电机堵转运行的时候，绕组的表现为纯电感。于是功率因素接近 0, ，但是电机要从电网汲取超大的电流。这些超大的电流最后都通过电线的电阻发热损耗掉了。&lt;/p&gt;
&lt;p&gt;电机在空载运行的时候，绕组表现依旧为纯电感。功率因素依旧接近 0 。 但是因为此时转子转速接近同步转速，因此电机产生的反电动势抵消了外部的驱动电压。空载运行时，电机反电动势会极为接近驱动电压。因此电流处于最小值。绕组实际电压为 驱动电压-反电动势电压。然后电流为此时电压下的电感电流。&lt;/p&gt;
&lt;p&gt;而电机正常的处于额定负载的情况下，会产生最大的功率因素。负载低于和高于额定负载，都会使电机的功率因素下降。&lt;/p&gt;
&lt;p&gt;因此，只要寻找到让电机功率因素最大的 频率/电压 组合，就可以在不知晓电机各项参数的情况下，获得接近直流电机般的转矩特性。&lt;/p&gt;
&lt;p&gt;而最大功率因素点跟踪，其思路就来自 太阳能控制器的最大功率点跟踪。&lt;/p&gt;
&lt;p&gt;具体做法是。使用 恒压频比，设定一个初始的频率。而算法的输出，为对初始频率的修正数。&lt;/p&gt;
&lt;p&gt;算法的观测器，为 功率因素。功率因素的获取方式很简单，就是通过电流采样，获取三相各自的电流值。将电流值与此时逆变器的输出电压比较，就可以获得电流相对电压的滞后角。通过滞后角，就得到了功率因素。&lt;/p&gt;
&lt;p&gt;此时算法会尝试 减少或者增加频率，然后观察功率因素的变化方向。
如果功率因素的变化方向，和频率的修正数同向，则电机目前工作在轻载模式。需要继续增加频率。&lt;/p&gt;
&lt;p&gt;如果功率因素的变化方向，和频率的修正数逆向，则电机工作在重载模式。需要降低频率。&lt;/p&gt;
&lt;p&gt;这样经过双向的尝试，控制器很快就能稳定在使功率因素最大的频率上。&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第三部分</title>
      <link>https://microcai.org/2023/11/30/saddle-wave-form-explain.html</link>
      <pubDate>Thu, 30 Nov 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/11/30/saddle-wave-form-explain.html</guid>
      <description>&lt;h1 id=&#34;轮子上的三条辐条&#34;&gt;轮子上的三条辐条&lt;/h1&gt;
&lt;p&gt;如果有一个轮子，半径为 1 ，在滚动的时候，其圆心会始终离地1高度。整个轮子的最顶端，也始终离地高度2.&lt;/p&gt;
&lt;p&gt;如果在这个轮子上，画出三条辐条。辐条夹角 120度。&lt;/p&gt;
&lt;p&gt;轮子在滚动的时候，辐条的顶部会完美的走过一个正弦波。波峰为 2. 中心为 1 。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;正弦波调制&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/sin.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这，就是正选波调制的三相电。其相电压的幅值为1。线电压为 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;msqrt&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msqrt&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;\sqrt{3}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;. 由于轮子最高处为2。
因此正弦波调制的直流电压利用率就是 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;msqrt&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msqrt&gt;&lt;mi mathvariant=&#34;normal&#34;&gt;/&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;\sqrt{3}/2&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/p&gt;
&lt;h1 id=&#34;去掉轮毂只留下辐条&#34;&gt;去掉轮毂，只留下辐条&lt;/h1&gt;
&lt;p&gt;因为没了轮毂，只留下辐条，于是，车轮前进的时候，辐条的端点划过的波，却不是正弦波了，而是一个马鞍波。&lt;/p&gt;
&lt;p&gt;因为车轮的中心，在上下跳动！&lt;/p&gt;
&lt;p&gt;于是，辐条的最高点，就不再是2了。因为车轮中心点最高的时候，恰恰两个辐条各自 120 分开。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;达不到2高度啊&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/saddle.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;达不到2高度啊！&lt;/p&gt;
&lt;p&gt;经过计算发现，其实车轮最大的高度，也只堪堪达到了 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;msqrt&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msqrt&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;\sqrt{3}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;这意味着，直流母线电压不需要为2 ，只需要 &lt;span class=&#34;katex&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;msqrt&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msqrt&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;\sqrt{3}&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt; 就能达到和之前一样的相电压输出！&lt;/p&gt;
&lt;p&gt;于是，会发现，在这种马鞍调制下，直流母线电压的利用率达到了 100%。&lt;/p&gt;
&lt;p&gt;虽然说，马鞍波的是各个相对 直流 地 的电压。&lt;/p&gt;
&lt;p&gt;但是，相和相之间的电压波形，依旧是完美的正弦波。因为其马鞍波，实际上是正弦波上叠加的一个三次谐波。车轮中心的上下运动，恰好抵消了这个谐波。&lt;/p&gt;
&lt;p&gt;于是相电压为完美的正弦波。而没有叠加的谐波。&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第二部分</title>
      <link>https://microcai.org/2023/11/29/operator-overload-to-change-float-math-to-int.html</link>
      <pubDate>Wed, 29 Nov 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/11/29/operator-overload-to-change-float-math-to-int.html</guid>
      <description>&lt;h1 id=&#34;引&#34;&gt;引&lt;/h1&gt;
&lt;p&gt;输出对称三相电的逆变器，总是要进行很多浮点运算。因此一般而言，需要使用带FPU的单片机。或者说叫DSP。&lt;/p&gt;
&lt;p&gt;如果只使用整数运算能否实现 svpwm 的计算呢？&lt;/p&gt;
&lt;p&gt;答案是能的，就是使用 “定点数”&lt;/p&gt;
&lt;p&gt;所谓定点数，就是和浮点数相对的，他的整数部分和小数部分是固定的。比如按 16bit 存储整数部分， 16bit 存储小数部分。这样一个 32bit 的定点数字，能表示的数字范围其实和 16位的整数一样。只不过它能额外的携带小数部分。&lt;/p&gt;
&lt;p&gt;而浮点数则是脱胎于科学计数法。比如使用 16bit 存储基数，另外16bit存储系数。则可以表示非常非常大的范围，只不过数字越大，误差就越大。大点的数字都没有小数部分了。所以这种数字表示法，他的小数点是浮动的。所以叫浮点数。&lt;/p&gt;
&lt;p&gt;浮点数其实有各种格式存储，但是为了互操作性， IEEE 定义了一个cpu上普遍使用的格式。IEEE 754。
如果单片机不支持浮点数运算指令，编译器就会用软件模拟。编译器带的软件浮点运算，速度非常非常慢。
这就是“浮点算不快”的由来。&lt;/p&gt;
&lt;p&gt;受限于成本，低端的单片机都不会搭载FPU。而中端的单片机，虽然搭载了FPU,但是 FPU 的速度不能和整数部分相提并论。只有使用较为高端的单片机，其搭载的 FPU 才算能用于 foc/svpwm 控制。&lt;/p&gt;
&lt;p&gt;这就极大的提高了电机控制器的成本。使得廉价控制器总是使用较为简单的只需要六步换向的方波驱动。而不是使用三相对称的正弦波驱动电机。&lt;/p&gt;
&lt;p&gt;那么有没有办法在廉价的单片机上使用 foc 呢？&lt;/p&gt;
&lt;h1 id=&#34;定点数学库&#34;&gt;定点数学库&lt;/h1&gt;
&lt;p&gt;其实是有的。不过将foc控制算法修改为定点数运算，需要修改大量的代码。而且简单的 + - * / 运算符号，统统被替换成了难看的，对定点数学库的调用。
需要修改的地方非常多。将程序改的面目全非。&lt;/p&gt;
&lt;p&gt;这就是 C 语言的弊病。 所以，就到了安利 C++ 的时间啦！&lt;/p&gt;
&lt;h1 id=&#34;定点数学库---header-only-cpp-plug-and-play&#34;&gt;定点数学库 - header only CPP plug and play&lt;/h1&gt;
&lt;p&gt;C++ 的优势，就是具有 “运算符重载” 功能。这个功能使得使用非编译器内置数字类型不需要改变使用方式。你仍然只需要使用正常的 + - * / 运算符。&lt;/p&gt;
&lt;p&gt;比如在所有代码里，凡是需要支持小数运算的地方，我统统使用 float_number 这个类型。&lt;/p&gt;
&lt;p&gt;然后在全局的一个 header 里，我用 using float_number = float;&lt;/p&gt;</description>
    </item>
    <item>
      <title>制作变频器-第一部分</title>
      <link>https://microcai.org/2023/11/25/vfd-part1.html</link>
      <pubDate>Sat, 25 Nov 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/11/25/vfd-part1.html</guid>
      <description>&lt;p&gt;为了验证，我决定亲自设计一款三相电源。这个电源可以随意设定电压和频率。&lt;/p&gt;
&lt;p&gt;三相电源，在任意时刻，可以由2个参数唯一确定： 电压/角度。
这个电压，指的是完整周期的相电压。因为三相的角度各相差120度。所以确定一个相的相位，就能自动推出另外2个相位。&lt;/p&gt;
&lt;p&gt;因此，在三相电源的核心逆变代码，只参考由上层传入的两个控制参数：电压和角度。&lt;/p&gt;
&lt;p&gt;有了角度，就可以知道任意相，他相对直流母线的电压因为 (sin(角度) /2 + 0.5)*电压。另外两相各加120度和240度即可。
如果把 电压设定为 0-1 之间的一个比例，也就是相对直流母线的电压，则算出来的值，就是每相的 上下管的导通之比。&lt;/p&gt;
&lt;p&gt;算出三相的PWM之比后，只要 mcu 设定为 中央对齐的 PWM 输出，就可以完美的输出指定角度的三相电了。&lt;/p&gt;
&lt;p&gt;然后再利用定时器，不断的更新 角度变量，就可以输出周期变化的三相交流电了。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-cpp&#34; data-lang=&#34;cpp&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; U_a &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; sin((electron_angle &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.0&lt;/span&gt;) &lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;180.0&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; pi) &lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2.0&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; U_b &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; sin((electron_angle &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;120.0&lt;/span&gt;) &lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;180.0&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; pi) &lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2.0&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; U_c &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; sin((electron_angle &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;240.0&lt;/span&gt;) &lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;180.0&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; pi) &lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2.0&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;U_a &lt;span style=&#34;color:#f92672&#34;&gt;*=&lt;/span&gt; throttle;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;U_b &lt;span style=&#34;color:#f92672&#34;&gt;*=&lt;/span&gt; throttle;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;U_c &lt;span style=&#34;color:#f92672&#34;&gt;*=&lt;/span&gt; throttle;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;pwm_set_duty(U_a, U_b, U_c);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;pwm 输出必须为中央对齐。可以大大降低开关损失。&lt;/p&gt;
&lt;p&gt;electron_angle 的更新，可以放到 定时器里，也可以放到 pwm 的中断响应里。&lt;/p&gt;
&lt;p&gt;electron_angle 的更新步进为，频率/pwm周期，如果 pwm 周期设定为 频率的整数倍 S，那么 electron_angle 的更新步进就是 360°C/S。&lt;/p&gt;
&lt;p&gt;每个pwm周期要执行三次 sin 运算。但是根据 三相和为 0 ，可以省去一个 sin 计算。简化为&lt;/p&gt;</description>
    </item>
    <item>
      <title>三相220v供电可行性研究</title>
      <link>https://microcai.org/2023/11/17/3phase-220v.html</link>
      <pubDate>Fri, 17 Nov 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/11/17/3phase-220v.html</guid>
      <description>&lt;p&gt;经过深思熟虑，我提出了一种新的居民用电供电模式： 即三相220伏4线制供电。以适应未来更大的入户功率需求。&lt;/p&gt;
&lt;p&gt;特点为：&lt;/p&gt;
&lt;blockquote&gt;
&lt;ol&gt;
&lt;li&gt;入户线路为3根火线，一条地线，没有零线。&lt;/li&gt;
&lt;li&gt;火线和火线之间的电压为220v。&lt;/li&gt;
&lt;li&gt;入户电表设计三相不平衡保护开关&lt;/li&gt;
&lt;li&gt;使用任意2条火线来兼容老的单相220v设备，继续提供 220v 的 2孔和3孔插座。&lt;/li&gt;
&lt;li&gt;三相设备使用4脚插座。&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;p&gt;不同供电制度下的对比如下：&lt;/p&gt;
&lt;p&gt;|               | 220v三相 | 220v 单相 | 380v 三相 | 240v直流 |
| 电压危险性     | 中 | 中 | 高 | 中 |
| 同功率下电流    | 中 | 大 | 小 | 中 |
| 同容量下线材成本 | 低 | 高 | 低 | 中 |
| 电能质量 | 高 | 低 （100hz功率波动） | 高 | 高 |
| 异步电机转矩 | 恒转 | 100hz 转矩波动 | 恒转 |  |
| 故障保护难度 | 低 | 低 | 中 | 高 |
| 整流后电压 |310v | 310v | 540v | 240v |&lt;/p&gt;</description>
    </item>
    <item>
      <title>逆摊丁入亩</title>
      <link>https://microcai.org/2023/11/16/tdrm.html</link>
      <pubDate>Thu, 16 Nov 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/11/16/tdrm.html</guid>
      <description>&lt;p&gt;税，都逃不过三大体系：人头税，资产税，流转税。
所谓人头税，就是按人头收税。在古时候，人头税是定额税。后来通过摊丁入亩废除了。
如今，人头税通过工资税的形式卷土重来。虽然不再是定额税。但是依旧是按人丁收取。&lt;/p&gt;
&lt;p&gt;资产税，就是按资产收税。一般采取的做法是按固定资产收税。古时候的摊丁入亩改革，正是以
资产税代替人头税。
如今，资产税在西方是非常普遍的。但在中国，房地产税迟迟未落地。
资产税的另一个重要征收方式叫通货膨胀，也叫铸币税。&lt;/p&gt;
&lt;p&gt;流转税，就是在商品的流通过程中收税。增值税，印花税，契税，关税，消费税，都属于流转税。&lt;/p&gt;
&lt;p&gt;在古代，主要依靠的是人头税，然后一部分资产税，几乎没有流转税。但是人民的流转税负担是少不了的，因为他们要通过向土匪交买路财，向城市黑社会交保护费的形式承担流转税。只不过这部分税收归属流氓，而不归政府。&lt;/p&gt;
&lt;p&gt;从明朝开始，统治者就意识到了人头税的弊端。而后有了张居正的改革，废除了人头税，改收以耕地为基础的资产税。这个改革从张居正开始直到雍正才真正落地。地多的多纳税，地少的少纳税。而不再由人口多寡决定税额。正是废除了人头税，中国的人口才起飞。当一个家庭的税负，不再由人口数量的多寡决定，那人多才能真正的力量大。才能放开了生。&lt;/p&gt;
&lt;p&gt;后来，1949年后，我们学习“西方的先进经验”，不分青红皂白的搬了西方的经验。重新捡起了在中国已经废除数百年的人头税。倒行逆施的结果就是摊亩入丁。
占有大量房子和土地的人不纳税。税主要由人数众多的底层老百姓承担。人头税的主要形式就是个人所得税和社保。&lt;/p&gt;
&lt;p&gt;结果就是生育率迅速下降。老龄化严重。&lt;/p&gt;
&lt;p&gt;人口越多，缴纳的税就越多，资产却无需纳税。这导致人口增长放缓，并进入人口萎缩时代。由于资产不纳税，资产开始膨胀。&lt;/p&gt;
&lt;p&gt;西方的老龄化社会，恰恰是因为西方普遍实现的“个人所得税”，也就是人头税。而不是所谓的经济发展导致的生育率自然下降。&lt;/p&gt;</description>
    </item>
    <item>
      <title>电池扫盲</title>
      <link>https://microcai.org/2023/10/08/batteries.html</link>
      <pubDate>Sun, 08 Oct 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/10/08/batteries.html</guid>
      <description>&lt;p&gt;作为资深老宅，路由器 nas 充电宝 这三大爱好是必不可少的。最近一友人买电池的时候，一着不慎着了相。买到了错误的电池。不得不花费重金重新采购合适的电池。
故有此文，以供参考。&lt;/p&gt;
&lt;h1 id=&#34;电池电压&#34;&gt;电池电压&lt;/h1&gt;
&lt;p&gt;家庭常见电池的电压如下&lt;/p&gt;
&lt;table&gt;
	&lt;thead&gt;
			&lt;tr&gt;
					&lt;th&gt;电池类型&lt;/th&gt;
					&lt;th&gt;标称电压&lt;/th&gt;
					&lt;th&gt;满电电压&lt;/th&gt;
					&lt;th&gt;空电电压&lt;/th&gt;
			&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
			&lt;tr&gt;
					&lt;td&gt;镍氢电池&lt;/td&gt;
					&lt;td&gt;1.2v&lt;/td&gt;
					&lt;td&gt;1.4v&lt;/td&gt;
					&lt;td&gt;1v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;干电池&lt;/td&gt;
					&lt;td&gt;1.5v&lt;/td&gt;
					&lt;td&gt;1.6v&lt;/td&gt;
					&lt;td&gt;0.9v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;碱性电池&lt;/td&gt;
					&lt;td&gt;1.5v&lt;/td&gt;
					&lt;td&gt;1.7v&lt;/td&gt;
					&lt;td&gt;1.2v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;锂铁电池&lt;/td&gt;
					&lt;td&gt;1.5v&lt;/td&gt;
					&lt;td&gt;1.8v&lt;/td&gt;
					&lt;td&gt;1.5v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;主板纽扣电池&lt;/td&gt;
					&lt;td&gt;3v&lt;/td&gt;
					&lt;td&gt;3.3v&lt;/td&gt;
					&lt;td&gt;2v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;磷酸铁锂电池&lt;/td&gt;
					&lt;td&gt;3.2v&lt;/td&gt;
					&lt;td&gt;3.6v&lt;/td&gt;
					&lt;td&gt;3v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;三元锂电池&lt;/td&gt;
					&lt;td&gt;3.7v&lt;/td&gt;
					&lt;td&gt;4.2v&lt;/td&gt;
					&lt;td&gt;3.3v&lt;/td&gt;
			&lt;/tr&gt;
			&lt;tr&gt;
					&lt;td&gt;1.5v恒压锂电池*&lt;/td&gt;
					&lt;td&gt;1.5v&lt;/td&gt;
					&lt;td&gt;1.5v&lt;/td&gt;
					&lt;td&gt;1.5v&lt;/td&gt;
			&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;其中，1.5v恒压锂电池 其实不是电池，而是一个内置锂电池的供电电源。电源稳压输出 1.5v。
其目的是使为 1.5v 干电池设计的用电器能直接使用锂电池工作。但是因为自身携带的dc/dc电路引入了损耗，因此不适宜用在需要长续航的用电器上（遥控器，钟表，门锁）。用在这些用电器上，往往其内部的锂电池的电量，主要被 dcdc 电路待机消耗掉，而不是对外输出。&lt;/p&gt;
&lt;h1 id=&#34;电池尺寸规格&#34;&gt;电池尺寸规格&lt;/h1&gt;
&lt;p&gt;电池通常制作成圆柱形。圆柱形电池有3种不同的规格表示法。&lt;/p&gt;
&lt;p&gt;其一为最常见的X号叫法。常见为1号电池，5号电池，7号电池。1号电池体积巨大，目前使用的地方为灶台点火器、燃气热水器点火器。因为体积巨大，所以容量很大，那些功率大，又同时不想频繁更换电池的地方就会用1号电池。7号电池苗条迷人，常用于对体积有要求的设备上。如遥控器。5号电池体积适中，如果不是特殊要求，一般就会使用5号电池。&lt;/p&gt;
&lt;p&gt;除了这种常见的号标电池，还有高度超低的圆柱电池，因为高度很低，虽然还是圆柱形，但是太像纽扣而得名“纽扣电池”。纽扣电池体积小，还超薄，所以广泛使用在迷你型遥控器上。如汽车遥控器。还有主板断电后维持时钟，都采用更薄的纽扣电池，而不是7号电池。纽扣电池虽然常见的就一种规格，但是也不是没有其他大小。纽扣电池的大小标记法为直径+高度标记。最常见的型号为 CR2032, 也就是 20mm 直径，3.2mm 厚度。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;CR927&lt;/li&gt;
&lt;li&gt;CR1025&lt;/li&gt;
&lt;li&gt;CR1216, CR1220&lt;/li&gt;
&lt;li&gt;CR1616, CR1620, CR1632&lt;/li&gt;
&lt;li&gt;CR2012, CR2016, CR2025, CR2032&lt;/li&gt;
&lt;li&gt;CR2320, CR2330, CR2354&lt;/li&gt;
&lt;li&gt;CR2450, CR2477&lt;/li&gt;
&lt;li&gt;CR3032, CR2412&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这么多不太常见的规格，其实都濒临淘汰了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>马赫原理</title>
      <link>https://microcai.org/2023/09/26/mahe-law.html</link>
      <pubDate>Tue, 26 Sep 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/09/26/mahe-law.html</guid>
      <description>&lt;p&gt;离心力是怎么来的？&lt;/p&gt;
&lt;p&gt;牛顿说，没有离心力。是因为旋转的时候，物体要维持直线运动。离心力是向心力的反作用力。
马赫说，离心力是星辰对旋转物质的引力。&lt;/p&gt;
&lt;p&gt;牛顿有着绝对时空观。运动是绝对的。宇宙有一个绝对静止的参考系。
马赫说认为一切都是相对的。旋转也是相对的。&lt;/p&gt;
&lt;p&gt;在牛顿水桶思想实验里，牛顿认为旋转的水桶最终会让水面凹陷。
马赫则认为没有参考系无法确定水桶是旋转的。没有星辰，就没有引力带来的离心力。也就不会引起水面凹陷。&lt;/p&gt;
&lt;p&gt;同时马赫认为，如果星辰少一半，离心力也会小一半。&lt;/p&gt;
&lt;p&gt;爱因斯坦同意马赫的相对性原则，但是并没有同意马赫说的星辰少一半离心力也少一半的说法。&lt;/p&gt;
&lt;h1 id=&#34;宇宙在增重&#34;&gt;宇宙在增重&lt;/h1&gt;
&lt;p&gt;根据大爆炸模型，宇宙是从无到有从虚空中诞生的。而宇宙诞生的时候，物质并不如如今那么丰富。
宇宙间的物质，是随着宇宙膨胀的过程增生出来的。&lt;/p&gt;
&lt;p&gt;因为重力势能也是能量的一种。宇宙膨胀，那么星系之间相互远离，结果就是星系之间的重力势能增加了。
于是宇宙膨胀本身就为宇宙凭空创造了大量的能源。
这增加的能量，就等于宇宙增加了质量&lt;/p&gt;
&lt;p&gt;按马赫原理，这些全宇宙增加的质量，就会增加离心力的大小。&lt;/p&gt;
&lt;h1 id=&#34;自转速度过大的星系&#34;&gt;自转速度过大的星系&lt;/h1&gt;
&lt;p&gt;所以宇宙早期，因为总质量更低，所以离心力也更低。于是早期(遥远)的星系就表现为有更大的自转速度。&lt;/p&gt;
&lt;p&gt;现在的天文观测确实发现了星系自转速度过大的问题。但是把这个现象归结为暗物质。
而如果应用马赫原理，承认离心力取决于全宇宙物质总量，则问题迎刃而解。&lt;/p&gt;</description>
    </item>
    <item>
      <title>明亡于重士轻工</title>
      <link>https://microcai.org/2023/09/16/ming-die.html</link>
      <pubDate>Sat, 16 Sep 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/09/16/ming-die.html</guid>
      <description>&lt;h1 id=&#34;明末财政危机&#34;&gt;明末财政危机&lt;/h1&gt;
&lt;p&gt;明朝末年，土地兼并严重。而大明的税收，是靠的 “自耕农”。自耕农破产，导致政府收不到税。
没钱就没兵。没兵就打不过满清。虽然是李自成灭的明朝，但是李自成攻入北京的时候，大明的精锐都在辽东打满清。可以说是满清吸引了大明的主力，让李自成差点摘了桃子。&lt;/p&gt;
&lt;p&gt;所以很多人说，大明亡于土地兼并。历朝历代皆如此。&lt;/p&gt;
&lt;h1 id=&#34;圈地运动&#34;&gt;圈地运动&lt;/h1&gt;
&lt;p&gt;在大明的士绅忙着土地兼并的时候，大英的贵族也在忙着搞圈地运动。
为何大明亡了，而大英却打败了西班牙成为新的海上霸主？&lt;/p&gt;
&lt;p&gt;难道大英不应该亡于土地兼并？&lt;/p&gt;
&lt;h1 id=&#34;儒教立国&#34;&gt;儒教立国&lt;/h1&gt;
&lt;p&gt;很多人认为，中国古代的封建王朝是以农业立国。其实不对。因为中国古代向来并不重视农业。
有人不信，拿出了古代各种重农抑商的政策来说明古代王朝以农业立国。&lt;/p&gt;
&lt;p&gt;那么为何，土豆在明朝传入中国，但要到清朝才大面积推广种植？
以农业立国的大明，却对粮食产量不甚关心？&lt;/p&gt;
&lt;p&gt;根本原因，是大明以儒教立国。&lt;/p&gt;
&lt;p&gt;儒家提倡的是阶级固定的社会。所以儒家定好士农工商四大阶级。并且禁止阶级流动。其中，
由于工商阶级对儒家的统治地位有威胁，所以儒家把工商定为贱籍。然后故意把农和士定为
高级人。本质是因为农对士毫无威胁。只要农不造士的反，农民吃不吃的饱的问题并不在士人
的关心范围内。&lt;/p&gt;
&lt;h1 id=&#34;压制流民&#34;&gt;压制流民&lt;/h1&gt;
&lt;p&gt;历朝历代，朝廷对流民都非常忌惮。因为失去土地的农民，只有两个去处：落草为寇和进城务工。
流民问题之所以难解决，是因为儒家并不希望流民进城务工。因为进城务工的流民，最终都会转换为工商阶级。所以儒家渲染流民只能落草为寇，必须恩剿并施。
所谓恩，就是分土地。所谓剿，无非就是镇压。
王朝初年，尚且可以同时两项操作，但在土地兼并的末期，往往只有剿一个办法。因为朝廷已经没有土地了。&lt;/p&gt;
&lt;p&gt;开疆拓土的时候，儒家会托词徒耗民力。不可轻起战事。
但是遇到流民的时候，儒家就不说好战必亡的话了。&lt;/p&gt;
&lt;h1 id=&#34;匠人世代为奴&#34;&gt;匠人世代为奴&lt;/h1&gt;
&lt;p&gt;朱元璋开创了中国版的种姓制度——匠户制和兵户制。&lt;/p&gt;
&lt;p&gt;兵户世代为兵，匠户世代为匠。&lt;/p&gt;
&lt;p&gt;虽然传统上，手工艺是家族代代传承的。但是这种家族传承的技艺有个弊病，就是无法形成理论体系。
每个工匠只知道自己家的那点道道。在宋代产生的资本主义萌芽，大商人开始雇佣大量的工人的时候，情况发生了变化。
商人对手下工人掌握的技术，肯定是不会让他们藏私，而是将大量工匠的技术结合起来，博采众长。并以商业世家的形
式进行集团化研究。于是就有了科学体系生长的温床。&lt;/p&gt;
&lt;p&gt;但是，明朝的匠户制打破了这一自发的自然过程。将科技重新“散户化”。&lt;/p&gt;
&lt;h1 id=&#34;散户匠人断科研路&#34;&gt;散户匠人断科研路&lt;/h1&gt;
&lt;p&gt;吃不饱的匠户，连传承知识都非常艰难。别提在前人基础上进行迭代了。
传承困难的一大佐证就是大量的匠户逃籍。&lt;/p&gt;
&lt;p&gt;于是匠人就越来越少了。大明的人口越来越多，但是从事科研的工作者却越来越少。难怪科技越来越倒退。&lt;/p&gt;
&lt;p&gt;科技倒退，导致大明严重依赖农业。所以圈地运动就成了亡国运动。而大英开设皇家科学院，圈地运动成了工业革命的催化剂。&lt;/p&gt;</description>
    </item>
    <item>
      <title>汽油机为何如此设计</title>
      <link>https://microcai.org/2023/09/14/why-this-way-1.html</link>
      <pubDate>Thu, 14 Sep 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/09/14/why-this-way-1.html</guid>
      <description>&lt;h1 id=&#34;冲程&#34;&gt;冲程&lt;/h1&gt;
&lt;p&gt;汽车发动机有四个冲程，吸气，压缩，做工，排气。
为何是这4个呢？&lt;/p&gt;
&lt;p&gt;热机要工作，必须要燃烧，燃烧就要空气。废气要排出，所以吸气排气是必须的。
但是为何要先压缩呢？&lt;/p&gt;
&lt;p&gt;原来早期阶段，热机是没有压缩这个阶段的。但是奥托发现了压缩能提高热效率。
于是奥托发明了四个阶段循环的发动机。后来这4个循环就被称作奥托循环。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/Stirling_Cycle.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;后来这4个循环，被热力学理论解构。也就是上图的4条线构成的框。热机对外的做工，就体现在这个框里。&lt;/p&gt;
&lt;p&gt;如果有教科书说是因为热力学的4个循环指导了内燃机的设计，那肯定是不对的。是先有的内燃机的设计，后来才有理论去解释。而有了理论后，后续的迭代开发才会使用理论来指导改进。&lt;/p&gt;
&lt;h1 id=&#34;吸的不是空气&#34;&gt;吸的不是空气&lt;/h1&gt;
&lt;p&gt;在奥托循环里，发动机吸气冲程吸入气缸的不是空气。而是汽油和空气的混合气。
为何不是吸的纯空气，然后在压缩的时候再注入汽油呢？&lt;/p&gt;
&lt;p&gt;因为发明汽油机的那个年代，还不存在燃油的高压喷嘴。而非高压喷嘴，就无法雾化燃油。
没有雾化的燃油，就没法迅速的爆燃。所以那个年代就是靠汽油的挥发性，让空气通过一个叫化油器的东西来吸入汽油。&lt;/p&gt;
&lt;p&gt;而汽油发动机的上限，就被这个吸入混合气的过程给锁死了。&lt;/p&gt;
&lt;p&gt;因为汽油发动机吸入的是混合气，所以汽油发动机就不能无限提高压缩比。
因为气体被压缩就会升温。而奥托循环必须要在做工冲程里燃烧汽油。
就要限制压缩循环里混合气的温升。不然混合气提前爆燃，就破坏了热力学循环。&lt;/p&gt;
&lt;p&gt;经过实验发现汽油发动机的极限压缩比在 12：1。超过就很容易让混合气提前爆燃。&lt;/p&gt;
&lt;p&gt;如果吸入的是纯粹的空气，就可以无限提高压缩比了。高压缩比带来的是更高的热力学效率和更大的动力。这个想法指导下，发明出来的发动机就是 “压燃发动机”，但是压燃发动机在很长一段时间内，都只能使用柴油作为燃料。而无法使用汽油。&lt;/p&gt;
&lt;p&gt;所以汽油发动机就一直停留在吸混合气阶段。而只要吸的是混合气，就无法提高压缩比。&lt;/p&gt;
&lt;h1 id=&#34;为何要先压缩&#34;&gt;为何要先压缩&lt;/h1&gt;
&lt;p&gt;我不用热力学的晦涩知识，就用最一般最容易理解的话来讲，为何要压缩。&lt;/p&gt;
&lt;p&gt;燃料在密闭腔室燃烧会产生高温高压的空气。这这个高温高压的空气就有了推动活塞做工的动力。
随着活塞被空气推动，热空气的温度和压力都会下降。理论上来说，这股热空气可以一直膨胀到温度等于室温，压力等于大气压。但是，活塞是有阻力的。温度下降到一定程度后，这股热气的压力就无法推动活塞了。这个无法推动活塞的废气，温度依旧高达600 - 800 度。&lt;/p&gt;
&lt;p&gt;所以，未点燃的混合气温度越接近废气的温度，则燃料的化学能就越是被活塞提取利用了。
如果未压缩，那么燃料燃烧的化学能，有一大部分就留存在废气的温度里。
而压缩提前让混合气的温度提高。那么此时化学能就更多的被利用于推动活塞做工。也就是提高了燃料的能源利用率。&lt;/p&gt;
&lt;p&gt;如果让混合气在点燃前的温度就和排气的温度一样，就意味着燃料的化学能被全部利用了。当然这并不表示引擎的效率达到了 100%，因为压缩本身就要使用掉一部分机械能。&lt;/p&gt;
&lt;h1 id=&#34;为何油门其实是气门&#34;&gt;为何油门其实是气门&lt;/h1&gt;
&lt;p&gt;发动机并不总是要 100% 的干活。很多时候，他都要少干活。
控制发动机干活多寡的东西俗称油门。但是油门实际上并不控制喷油量。
油门直接控制的，是进气量。然后由于汽油发动机需要始终如一的空燃比，所以喷油器会减少喷油。
减少喷油是减少吸气的结果。&lt;/p&gt;
&lt;p&gt;如果油门控制的是喷油，而进气量不变，就很容易导致在小油门的情况下发生富氧燃烧。
也就是氧气的量大大超过燃油的量。&lt;/p&gt;
&lt;p&gt;正如缺氧燃烧会产生一氧化碳一样，富氧燃烧一样会产生污染物氧化氮。
为了减少尾气中的氮氧化物和一氧化碳，汽油和空气必须按比例混合。既不能让空气多，也不能让汽油多。&lt;/p&gt;
&lt;p&gt;所以，减少发动机出力，不能只靠减少喷油。而必须同步减少吸气量。&lt;/p&gt;
&lt;p&gt;恰恰汽油发动机调节功率靠的是调节进气量，导致汽油发动机实际压缩比是动态变化的。
动态变化的压缩比又导致汽油发动机无法采用“压燃”。&lt;/p&gt;
&lt;p&gt;而柴油污染大，恰恰是因为压燃的特点导致柴油在小油门下，是富氧燃烧。而大脚轰油门的时候，又是富油燃烧。导致不管是小油门还是大脚油门，都会产生严重的污染。&lt;/p&gt;
&lt;p&gt;大脚油门下排的黑烟，要靠“颗粒捕捉器” 去除未燃烧的碳。
小脚油门下排的氮氧化物，要靠 “尿素” 去除。&lt;/p&gt;
&lt;p&gt;如果要让柴油机减少污染，就只能让柴油机以固定的空燃比燃烧。。。 也就是固定扭矩使用。然而除非只用来当增程器，否则如此工况是断不可能满足的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>中国古代名词解释</title>
      <link>https://microcai.org/2023/05/23/guwen-xinjie.html</link>
      <pubDate>Tue, 23 May 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/05/23/guwen-xinjie.html</guid>
      <description>&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;士绅优待
士绅优待, 指儒教免税. 是儒教自汉代罢黜百家后, 为儒教教徒门争取到的阶级红利.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;士绅一体纳粮
指取消儒教特权. 是雍正未雨绸缪, 要为将来朝廷收不到自耕农的税后找退路. 从农民手上收钱改为从儒教收钱.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;与民争利
指朝廷把税扩大到工商阶级. 朝廷要求商人纳税会导致商人地位上升. 威胁儒教地位. 所以儒教要求朝廷不得与民争利.
只收农业税, 就可以把科举取士范围局限在士人阶级 ( _ 农民只有理论上参与科举的权利 _ ).
工, 在古时候是指不读四书五经, 而学习科技的那批人. 这些读书人如果参与科举, 会严重影响到四肢不勤五谷不分的
儒教地位. 正好这些人也没多少钱, 就给予他们免税. 所以朝廷只收农业税, 对儒教是最稳妥的.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;藏富于民
指朝廷应该满足于农业税. 而让士人和商人掌握社会财富. 不要想着收商税, 不要想着士绅一体纳粮. 要做到藏富于民.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;功高震主
指皇帝不应该重用非儒教出身的勋贵阶级. 不然就算他们不造反, 儒教的人也不介意推他们一把.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;歪理小说
指四书五经以外的知识。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</description>
    </item>
    <item>
      <title>罢黜百家, 自绝天下</title>
      <link>https://microcai.org/2023/05/22/rujia-wuguo.html</link>
      <pubDate>Mon, 22 May 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/05/22/rujia-wuguo.html</guid>
      <description>&lt;p&gt;春秋战国时期, 中华大地上是百家争鸣.
何谓百家?&lt;/p&gt;
&lt;p&gt;研究回字写法是家, 研究如何让弓箭射的更远也是家.
百家, 不仅仅是文学上的百家, 也有理学工学上的百家.&lt;/p&gt;
&lt;p&gt;比如, 兵家, 研究兵法. 研究战阵. 不研究回字的9种写法.
农家, 研究农业, 改良种子, 改进犁具, 不研究回字的9种写法.
墨家, 研究机关, 改进工具, 不研究回字的9种写法.
医家, 研究医术, 治病救人, 也不研究回字的9种写法.&lt;/p&gt;
&lt;p&gt;但是, 这些不研究回字的9种写法的百家, 都不受研究回字的9种写法的儒家待见.
到秦朝初立, 百家就被儒家排挤的差不多了. 朝堂上就只剩下法家在苟延残喘了.&lt;/p&gt;
&lt;p&gt;法家对儒家的最后一击, 就是焚书坑儒.
儒家对法家的报复, 就是天下大乱.&lt;/p&gt;
&lt;p&gt;最后儒家一统天下, 罢黜百家, 独尊儒术.&lt;/p&gt;
&lt;p&gt;如果儒家罢黜的是其他研究回字写法的家, 那倒也没啥问题.
关键问题在于, 儒家罢黜的, 可不止是研究回字写法的家, 更是罢黜了数学家, 化学家, 医学家.
儒家把不研究回字写法的, 统统贬为 &amp;ldquo;奇技淫巧&amp;rdquo;.
不仅仅在朝廷上取缔, 更是在民间也取缔.&lt;/p&gt;
&lt;p&gt;从此, 中国社会陷入了2000年的停滞.&lt;/p&gt;
&lt;p&gt;很多人说, 儒家给中国带来了大一统. 其实是错误的. 给中国带来大一统的是法家. 秦以法家治国.
法家有大一统思想. 灭六国后, 法家坚持废除分封, 行郡县制. 儒家非要恢复周制, 行分封.&lt;/p&gt;
&lt;p&gt;刘备可是嬴政小谜弟, 他夺得天下后, 不得不 外儒内法.
外儒内法, 就是让法家变成1对1传承. 只有历代皇帝学法家. 天下人皆学儒家.&lt;/p&gt;</description>
    </item>
    <item>
      <title>中国人发明了数学</title>
      <link>https://microcai.org/2023/05/07/chinese-invented-math.html</link>
      <pubDate>Sun, 07 May 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/05/07/chinese-invented-math.html</guid>
      <description>&lt;p&gt;很多人学习数学的时候很好奇, 为何全世界的数学都是十进制的. 然后就有谣言说, 是因为人有十指. 所以全世界的人都发明了十进制的数学.&lt;/p&gt;
&lt;p&gt;其实并不是. 虽然以符号语言为基础的数学确实是十进制体系的, 但是各个国家的语言里的数, 却并不是十进制体系的. 如果说原始人因手有十指就发明了数, 为何各种语言里, 数不都是十进制的?
难道原始人发明语言里的数的时候, 故意和他们的学科上的数学唱反调? 或者说, 原始人是先学会数学后学会说话? 既然是先学会说话后学会数学, 必然后学会的数学, 肯定使用语言里本身的进制.&lt;/p&gt;
&lt;p&gt;如果当今的数学是十进制的, 必然是因为这门学科, 诞生自一个使用十进制口语的民族.&lt;/p&gt;
&lt;p&gt;而口语不是十进制的民族, 其数学必然是舶来品, 而不是一个原生的发明.&lt;/p&gt;
&lt;p&gt;阿拉伯数字, 恰恰是古代阿拉伯人(一说是古印度人)为了学习某个古老民族的数学, 但是又无法承担学习其古老文字的代价而发明的助记符.
随着阿拉伯数字的扩散, 十进制的数学最终统一了世界.&lt;/p&gt;
&lt;p&gt;但是, 阿拉伯数字只统一了写在纸上的数学, 并没有统一口中说出的数学. 这也是另一种形式的 书同文, 但是语不同音.&lt;/p&gt;
&lt;p&gt;其实, 古老的民族里, 各种进制的数学都要. 而且更为广泛使用的其实是12进制. 在古汉语里, 12进制的遗留就是如今大家熟知的子丑寅卯. 12进制的源头, 来自月亮. 一年月圆12次. 于是古代先民发明了12进制. 但是同时古代先民也发明了十进制. 两种系统互相碰撞, 融合为六十进制的天干地支计数. 但是最终10进制胜出.&lt;/p&gt;
&lt;h1 id=&#34;一个数字如何表示又如何念&#34;&gt;一个数字如何表示又如何念&lt;/h1&gt;
&lt;p&gt;一个数字如何表示, 首先是确定进制. 然后将这个数字按进制下, 写下每个位的权重.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;比如 96, 由于阿拉伯数字是十进制的, 因此 96 的含义, 其实是 10进位上是9 , 个位上是6, 其表示的数量, 就是 九个十加六. 念 九十六&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;如果表示为 16 进制 (0123456789ABCDEF), 则是 表示为 60 , 表示 sixteen进位上是 6 , 个位上是 0. 也就是 6*(sixteen) + 0, 在 16进制的语言里, 念 6 sixteen zero.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;如果表示为 20 进制, (0123456789ABCDEFGHIK) 则表示为 4G 念 4 vingt sixteen.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</description>
    </item>
    <item>
      <title>谁在害怕英语主科地位消失</title>
      <link>https://microcai.org/2023/03/06/we-must-boycot-english.html</link>
      <pubDate>Mon, 06 Mar 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/03/06/we-must-boycot-english.html</guid>
      <description>&lt;p&gt;每隔几年, 就有代表提议取消英语主科地位. 每次都无功而返.&lt;/p&gt;
&lt;p&gt;每次网上掀起取消英语地位的讨论, 都有很多很多的反对声.&lt;/p&gt;
&lt;p&gt;支持取消英语主科地位的有两类人&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;A类是学习不好, 少学一门是一门. 取消啥学科他们都支持.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;B类是坚信 为中国人不再学英语而努力的学好英语. 如今他们长大了, 觉得时机成熟了&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;而不支持英语取消主科地位的有三类人&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;C类, 自然是搞英语培训产业的. 都上市公司了, 总不能一夜回到解放前吧.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;D类是布林肯. 他反对中国中国在边疆地区普及普通话. 说边疆的孩子学了普通话, 就丢掉了自己的文化. &lt;img alt=&#34;不能学普通话啊&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/blk-anti-han.png&#34;&gt; 同时他大力赞扬 乌兹别克斯坦人学英语 &lt;img alt=&#34;学英语才能当好奴才&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/blk-promot-english.png&#34;&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;剩下的F类则是被不林肯忽悠瘸了, 认为国家取消英语地位, 就没人学, 也没人教了. 然后他们想出国或者搞科研要研究国外的文献, 就得自己掏钱去培训班花大钱了.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;CD两类人知道自己的观点是站不住脚的. 所以他们采取的策略, 就是不断的在庞大的F类人里寻找代理, 用巨大的水军, 把妄图取消英语地位的人淹死.
而F人的诉求, 看起来是多么的冠冕堂皇, 使得反对者禽兽不如了. 他们污蔑学不好的A类人, 说他们是笨蛋, 还说不取消英语地位, 就是为了鞭策他们好好学习. 他们污蔑学的好的B了类人, 说他们是居心不良, 是想让A类人永远法挑战他们了. 这是在挑动 AB类的内斗.&lt;/p&gt;
&lt;p&gt;但是 B 类的人永远是人数稀少, 数量庞大的A类的人一听 F 类的歪理, 就不自觉的和B类的人划清界限了.&lt;/p&gt;
&lt;p&gt;于是, ACDF 合起来反对 B 类人, 使得他们的努力一直在作废.&lt;/p&gt;
&lt;p&gt;近年来的趋势就是 A F 类的人在觉醒. A 类的人明白过来, 如果非要少一门学科, 那只能是英语. 谁要说取消语文数学, 他们不会再支持. F 类的人也逐渐的明白过来, 即使中国取消英语的地位, 也不是闭关锁国.&lt;/p&gt;</description>
    </item>
    <item>
      <title>都是唐人</title>
      <link>https://microcai.org/2023/03/03/we-are-all-from-datang.html</link>
      <pubDate>Fri, 03 Mar 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/03/03/we-are-all-from-datang.html</guid>
      <description>&lt;p&gt;秦始皇统一了天下, 从此大家都是秦人. 刘邦建立汉朝后, 大家都是汉人.&lt;/p&gt;
&lt;p&gt;李世民建立大唐后, 从此大家都是唐人.
千年后, 哪怕远去他乡, 还自称 &amp;ldquo;新唐人&amp;rdquo;&lt;/p&gt;
&lt;p&gt;那么, 唐人都有哪些呢?&lt;/p&gt;
&lt;p&gt;首先看大唐的疆域.&lt;/p&gt;
&lt;p&gt;大唐的疆域, 西到碎叶城, 北至北冰洋 东北到日本海, 东到东海, 南到南海, 西南到喜马拉雅山.&lt;/p&gt;
&lt;p&gt;为历朝历代最大. 而且全部都派遣了官吏治理, 而不是粗旷式的治理. 凡此疆域内诞生的人民, 即是大唐的子民. 都享有读书做官的权力.&lt;/p&gt;
&lt;p&gt;最西部碎叶城出生的李白, 都能到长安做官, 而不是所谓的 &amp;ldquo;化外之民&amp;rdquo;.&lt;/p&gt;
&lt;p&gt;因此, 以后, 凡是在这片区域内诞生的人, 都可以&amp;quot;争天下&amp;quot;. 哪怕大唐亡国了, 他们也可以说他们的先祖曾是大唐的子民.&lt;/p&gt;
&lt;p&gt;有人要反驳, 说大唐的北部疆域到不了北冰洋.
那么请问, 大唐的北边还有敌人吗? 既然北边没有敌人, 你怎么能给这些地方生造一个主人呢?
没有敌人, 领土自然是自动延伸到海岸线.&lt;/p&gt;
&lt;p&gt;你不能说, 只有唐人走到过的领土才算唐人的领土. 冰岛人真的走完所有冰雪覆盖了的冰岛了吗?&lt;/p&gt;
&lt;p&gt;既然大唐建立了安北都护府, 并且没有第二个国家反对大唐的主权伸张, 不能因为安北都护府的人没有走到北冰洋, 就说大唐的领土北不达北冰洋.&lt;/p&gt;
&lt;p&gt;西达碎叶城, 是因为更西的地方, 是阿拉伯人的底盘. 向西扩充, 就会遇到阿拉伯人的抵抗.
只能靠武力扩张, 而大唐兵力最西也只能抵达碎叶城.&lt;/p&gt;
&lt;p&gt;当时大唐向东北扩展, 就遇到了另一个国家的阻挠. 那就是高句丽.
很多人把高句丽看成是半岛政权. 那是不对的.&lt;/p&gt;
&lt;p&gt;高句丽盘踞半岛和辽东的肥沃土地. 阻碍了大唐向东北的扩张.
所以, 大唐必灭之.&lt;/p&gt;
&lt;p&gt;高勾丽灭后, 高句丽的领土, 自然就纳入大唐的版图. 同时, 没了高勾丽的阻碍, 大唐可以继续向东北扩张.
然后为了管理东北, 建立了安东都护府. 唐人向东北扩展, 只要没遇到另一个国家, 大唐的领土应该也是自动延伸到海岸线为止.&lt;/p&gt;</description>
    </item>
    <item>
      <title>电机和电车的一点想法</title>
      <link>https://microcai.org/2023/02/28/thoughts-on-motor-and-ev.html</link>
      <pubDate>Tue, 28 Feb 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/02/28/thoughts-on-motor-and-ev.html</guid>
      <description>&lt;p&gt;除了有刷电机外, 无电刷的电机, 驱动起来是一门学问.&lt;/p&gt;
&lt;h1 id=&#34;反电动势&#34;&gt;反电动势&lt;/h1&gt;
&lt;p&gt;在讲解这门学问前, 先回顾一下物理学上的一个公理, 能量守恒定律. 能量守恒定律在电机控制领域非常重要, 电机的很多特性, 都来自宇宙要遵守能量守恒定律导致的.&lt;/p&gt;
&lt;p&gt;反电动势是电机达成能量守恒定律的一个重要手段.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;电机的输入电流 = (电池电压\*占空比 - 电机反电动势) / 绕组阻抗
绕组电流 = 电池电压\*输入电流 / 反电动势
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里面的原因是, 电机的输入电流, 也就是从电池汲取的电流, 功率 = 电池电压*电机输入电流.&lt;/p&gt;
&lt;p&gt;但是, 电机的扭矩来自于绕组的电流(达到磁通饱和前, 电机扭矩正比于绕组电流), 而和电机的转速无关. 因此绕组电流和输入电流不是一回事.
如果绕组电流等同于电池供应给电机的电流, 那么电机就违背了能量守恒定律.&lt;/p&gt;
&lt;p&gt;因为电机的功率 = 扭矩*转速, 而反电动势正比于转速, 扭矩正比于绕组电流. 所以电机的功率 = 绕组电流*反电动势&lt;/p&gt;
&lt;p&gt;这里, 就要得出一个 绕组电流*反电动势 = 电池电压*电机输入电流 的能量守恒来.&lt;/p&gt;
&lt;p&gt;如果电机没有反电动势, 能量守恒就要被破坏.&lt;/p&gt;
&lt;p&gt;正是因为绕组电流和电池供应的电流不同, 所以电机控制器, 不仅仅承担为电机&amp;quot;电子换相&amp;quot; 的工作, 也承担 DC/DC 变压的工作. 准确的来说, 是 Buck Converter.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;降压变换器电路图&#34; loading=&#34;lazy&#34; src=&#34;https://upload.wikimedia.org/wikipedia/commons/thumb/3/33/Buck_circuit_diagram.svg/600px-Buck_circuit_diagram.svg.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;绕组电流需要&amp;quot;续流二极管&amp;quot; 的存在, 这个存在, 是由开关管上的寄生二极管承担的.&lt;/p&gt;
&lt;p&gt;因此, 在电机控制器里, 承受功率的开关管, 其工作电流实际上是和电机扭矩有关, 而和电机输出功率无关. 正是为了保护控制器里的开关管, 同时也避免电机内部磁通饱和, 所以电机的扭矩调教为 初段恒扭矩, 后段恒功率.&lt;/p&gt;</description>
    </item>
    <item>
      <title>GUI 渲染延迟</title>
      <link>https://microcai.org/2023/02/17/gui-render-latency.html</link>
      <pubDate>Fri, 17 Feb 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/02/17/gui-render-latency.html</guid>
      <description>&lt;p&gt;鼠标点击窗口标题栏, 然后快速拖动. 如果窗口和鼠标紧紧贴到一起, 那么恭喜你, 你的OS并没有GUI渲染延迟问题.
但是, 经过实验后, 各位想必都会发现, 往往是鼠标指针先到达, 然后窗口才会跟过去. 窗口的移动似乎总是延后于鼠标指针.
如果各位是从旧时代过来的人, 应该还记得, 早期的 WinXP, 窗口拖到是非常跟鼠标的.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;没有渲染延迟问题的意思是, UI 的反应总是在下次屏幕刷新的时候出现. 也就是最多延迟为一帧, 最少可以恰好没延迟. 平均延迟时间为 0.5帧.

我们设想屏幕为班车, 如果设定刷新率为 60hz, 就是每 1/60 s 就发车. 而用户的输入, 就像随机到站的乘客.
如果到站后, 总是能乘坐下一趟车, 那么就可以认为 UI 没有延迟. 虽然总体上是平均延迟了 0.5帧, 但是本篇
不考虑总延迟, 只考虑 &amp;quot;错过&amp;quot; 班车的情况. 因此我以 &amp;quot;错过&amp;quot; 班车的数量来定义延迟. 因为鼠标指针的绘制,
是独立的路径, 因此鼠标指针永远不会错过班车. 但是, 窗口的内容绘制, 可能会错过班车. 所以可以以拖动窗口
来观察渲染延迟.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如今不跟了, 主要原因, 其实是现在普遍使用的桌面混成功能导致的.
在非混合时代, 窗口的内容是直接对应显卡上的屏幕输出缓冲区. 而在桌面混成时代, 所有的窗口都有一个独立的缓冲区. 由混成器
将这些图片合成到屏幕上. 也就是说, 要将大量的图片, 合成为一张图片.&lt;/p&gt;
&lt;p&gt;而混成器, 为了避免屏幕撕裂, 必然会打开垂直同步. 可是, 打开垂直同步, 为何会导致错过班车呢?
这就不得不说到目前的 UI 库了. 目前 gui 程序使用的 UI 库本身, 也是打开了垂直同步的.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Wayland 已经可用</title>
      <link>https://microcai.org/2023/02/15/wayland-usable-now.html</link>
      <pubDate>Wed, 15 Feb 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/02/15/wayland-usable-now.html</guid>
      <description>&lt;p&gt;2023 年情人节, KDE 终于发布了 5 系列的最后一个版本: 等离子 5.27&lt;/p&gt;
&lt;p&gt;经过十几年的雕琢, wayland 终于可用了.&lt;/p&gt;
&lt;p&gt;既然 wayland 可用, 我就迫不及待的要删掉 Xorg 了.&lt;/p&gt;
&lt;p&gt;给 xorg-server 去掉了 xorg, &lt;code&gt;USE=-xorg emerge xorg-server&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;然后 /usr/bin/Xorg 就拜拜了. 至于为啥还要编译 xorg-server, 是为了他提供的 Xwayland .&lt;/p&gt;
&lt;p&gt;Xorg 没了后, 就可以顺利卸载 xorg-drivers xf86-video-* xf86-input-* 驱动了. Xwayland 并不使用这些驱动.&lt;/p&gt;
&lt;p&gt;Xwayland 是不使用 Xorg 的驱动的. Xwayland 从 kwin 获得输入, 因此无需 xf86-input-* 驱动, Xwayland 本身是作为一个 wayland 客户端, 因此也不需要
xf86-video-* 驱动操作显卡. wayland 客户端用啥 GL 驱动绘制, Xwayland 也用啥 GL 驱动绘制. 驱动的自动选择交给了 libglvnd.&lt;/p&gt;
&lt;p&gt;要同时给 Xorg 和 Mesa 写2个驱动的时代终于过去了. 虽然 Xwayland 仍然保留 X11 兼容性, 但是 Xwayland 不需要专门的驱动了.&lt;/p&gt;</description>
    </item>
    <item>
      <title>面向公知治国</title>
      <link>https://microcai.org/2023/01/26/gongzhi-oriented-governance.html</link>
      <pubDate>Thu, 26 Jan 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/01/26/gongzhi-oriented-governance.html</guid>
      <description>&lt;p&gt;古时候, 有一个皇帝, 他对于如何治理国家没有主见. 于是他就很喜欢听公知的话.&lt;/p&gt;
&lt;p&gt;当时, 公知说, 太监都是坏人, 尤其是那个魏忠贤, 大大的坏.&lt;/p&gt;
&lt;p&gt;于是他砍了魏忠贤.&lt;/p&gt;
&lt;p&gt;公知说, 锦衣卫只抓好人.&lt;/p&gt;
&lt;p&gt;于是他撤了锦衣卫.&lt;/p&gt;
&lt;p&gt;公知说, 勤俭的皇帝是好皇帝. 于是他每天“鸡鸣而起，夜分不寐”，宫中从无宴乐之事。&lt;/p&gt;
&lt;p&gt;他这么节俭, 国库还是没钱. 他想增加国库收入, 公知说, 要藏富于民, 不能与民争利.
于是他放弃了江南的商税.&lt;/p&gt;
&lt;p&gt;外有鞑子, 内有闯王. 为了抵御外敌, 他听从公知的建议加征三响. 还只收北方的.&lt;/p&gt;
&lt;p&gt;后来公知说, 袁崇焕投敌啦. 于是他马上斩了袁崇焕.&lt;/p&gt;
&lt;p&gt;最后走投无路了, 他发现他什么也没做错, 为啥就亡国了呢?&lt;/p&gt;
&lt;p&gt;今也有一皇帝, 事事听公知的.&lt;/p&gt;
&lt;p&gt;公知说, 新冠很危险. 能打赢新冠的只有民主和自由. 于是他封城了. 他要公知闭嘴.
后来, 公知说, 新冠就是大号流感. 人民要生活, 不能封城. 于是他躺平了.
公知说, 放烟花是自由. 于是烟花又能放了.&lt;/p&gt;
&lt;p&gt;公知说, 武统台湾就会被美国以贸易战报复. 于是他不敢武统.
公知还说了, 辉瑞特效药好, 不让引进就是故意杀人. 于是他引进了辉瑞神药. 但是引进后马上遭遇了老百姓的强烈抵制.&lt;/p&gt;
&lt;p&gt;对了, 公知还说, 中兴被美国制裁是咎由自取, 于是他带着中兴给美国请罪.&lt;/p&gt;</description>
    </item>
    <item>
      <title>悟空和观音谁的修为高?</title>
      <link>https://microcai.org/2023/01/21/monky-vs-guanyin.html</link>
      <pubDate>Sat, 21 Jan 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/01/21/monky-vs-guanyin.html</guid>
      <description>&lt;p&gt;悟空在西游结束后, 被封为斗战胜佛. 而一路上帮助他的观音依旧是菩萨.
在灵山教里, 佛大于菩萨大于罗汉. 很多人对一个毛猴突然站观音头上不接受. 于是自欺欺人的说悟空地位低于菩萨.&lt;/p&gt;
&lt;p&gt;首先, 佛和菩萨, 是以什么为划分的? 地位又是以什么为划分的?&lt;/p&gt;
&lt;p&gt;西游世界, 他是一个修仙世界. 修仙世界, 实力为尊. 这就是为何, 年纪更大, 资历更老的人太上老君, 要屈尊于玉帝之下.
因为这个世界, 其实是按实力说话.&lt;/p&gt;
&lt;p&gt;按实力排行, 观音高于悟空.
那么为何悟空成佛, 观音还是菩萨呢?&lt;/p&gt;
&lt;p&gt;这涉及到另灵山教的一个规定. 就是佛和菩萨, 不是以实力划分的. 而是以对佛法的领悟划分的. 对佛法的领悟更高者成佛.
次之则为菩萨. 再次则为罗汉.&lt;/p&gt;
&lt;p&gt;也就是说, 佛和菩萨的区别, 是一个纯粹的学术排名, 而不是实力排名.
其实看西游记就会发现, 到了后期, 悟空对佛法的参悟, 其实已经远远甩开其他人了, 连唐僧都要向悟空讨教.
不过唐僧最后排名高悟空一个名次, 其实主要是因为成佛后, 唐僧取回了金蝉子的记忆. 也就是说, 凡人唐僧对佛法的领悟,
不过区区二十几年, 不如后来大彻大悟的孙悟空. 但是取经成功后, 继承了金蝉子的记忆, 自然对佛的领悟重新超过孙悟空.&lt;/p&gt;
&lt;p&gt;那么悟空成佛, 是不是对佛法的领悟要高于菩萨呢?&lt;/p&gt;
&lt;p&gt;这也不见得. 因为学术排名还有个前提, 人家要参与排名.
观音拿到菩萨学位后, 就放弃了成佛. 因此她对佛的参悟到底几何, 已经无人知晓了.&lt;/p&gt;
&lt;p&gt;也就是说, 佛和菩萨的区别, 是一个学术上的区别. 不是实力上的区别.&lt;/p&gt;
&lt;p&gt;那么, 按实力来说, 观音的实力如何呢?&lt;/p&gt;
&lt;p&gt;人的修为是可以增长的. 比如天庭里很丢人的太白金星, 年纪在天庭都是数一数二的人物, 但是因为修为增长遇到瓶颈. 战斗力是个只有5的渣.
而悟空呢? 刚去菩提座下学了十几年, 实力就已经超过东海龙王了. 这修练速度是非常逆天的. 哪怕是消炎都自叹不如.&lt;/p&gt;</description>
    </item>
    <item>
      <title>sfp 形态 gpon 光猫失败</title>
      <link>https://microcai.org/2022/12/17/gpon-sfp-onu-success.html</link>
      <pubDate>Sat, 17 Dec 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/12/17/gpon-sfp-onu-success.html</guid>
      <description>&lt;p&gt;多年前, 折腾过一次 &lt;a href=&#34;https://microcai.org/2019/07/30/gpon-sfp-onu-failed.html&#34;&gt;sfp 形态 gpon 光猫失败&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;时隔三年半, 我又开始折腾 sfp 猫棒了.&lt;/p&gt;
&lt;p&gt;这次非常顺利, 一次成功.&lt;/p&gt;
&lt;p&gt;主要是固件好用起来了. 改好 SN , 填好 password 搞定.&lt;/p&gt;</description>
    </item>
    <item>
      <title>高房间必然没有高科技</title>
      <link>https://microcai.org/2022/12/05/high-estate-price-conflict-with-hightech.html</link>
      <pubDate>Mon, 05 Dec 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/12/05/high-estate-price-conflict-with-hightech.html</guid>
      <description>&lt;p&gt;国家要发展, 必然要有高科技. 科技是第一生产力.&lt;/p&gt;
&lt;p&gt;而高科技, 必然和高房价是冲突的.&lt;/p&gt;
&lt;p&gt;第一点: 高科技对土地的需求非常大. 高科技必然意味着大量的研发. 研究就得做实验. 做实验就需要实验室. 有实验室就必须要有大量仪器设备.
这些仪器设备对环境要求苛刻, 必然需要大量的专用房子. 因此科研需要大量的土地.
高房价必然大大推高科研成本. 高科研成本必然导致败给低科研成本的对手.&lt;/p&gt;
&lt;p&gt;第二点: 高科技需要大量高级人才. 高房价必然推高人才的期望待遇. 搞科研, 除了要支付自身的土地需求, 还得间接的支付人员的土地需求.
于是高房价必然导致过高的人员支出. 大大推高科研成本. 高科研成本必然导致败给低科研成本的对手.&lt;/p&gt;
&lt;p&gt;所以, 高房价必然没有高科技. 即便是有, 那也是靠畸形补贴政策催生的, 一旦失去补贴, 立马败给同行.&lt;/p&gt;
&lt;p&gt;所以, 需要高科技的新能源汽车, 必然不可能诞生于北汽和上汽.
需要高科技的芯片行业, 也必然不可能诞生于北京上海.&lt;/p&gt;
&lt;p&gt;正如纽约也造不出芯片, 造不出汽车.&lt;/p&gt;
&lt;p&gt;高科技, 需要高人才, 必然需要大学城.
因此大学城必然需要建设在低房价的地方.&lt;/p&gt;
&lt;p&gt;在高房价的地方建设大学, 大学生面对的将是绝望.
绝望就会催生革命的动力. 必然会被野心家利用.
被利用, 必然就会拿着A4纸上街游行.&lt;/p&gt;</description>
    </item>
    <item>
      <title>platformIO 单片机开发神器</title>
      <link>https://microcai.org/2022/11/12/platformio.html</link>
      <pubDate>Sat, 12 Nov 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/11/12/platformio.html</guid>
      <description>&lt;p&gt;近来闲暇无事，想弄个三相变频器玩玩。
三相变频器可以用来驱动异步电机，还可以驱动直线加速器。&lt;/p&gt;
&lt;p&gt;于是搜索万能宝，发现只有380v的变频器。&lt;/p&gt;
&lt;p&gt;可是我想玩安全电压的。最多24V三相交流电。&lt;/p&gt;
&lt;p&gt;找不到，看来只能自己开发一个了。&lt;/p&gt;
&lt;p&gt;硬件不用自己做，只要购买无刷电机驱动板就可以了。
无刷电机驱动板，只要提供3路PWM信号，就可以生成驱动无刷电机用的三相交流电。&lt;/p&gt;
&lt;p&gt;而生成这pwm信号的工作，就留给了单片机。&lt;/p&gt;
&lt;p&gt;我比较中意的单片机是 ESP32. 便宜，性能强。STM32 零头的价格提供了比 STM32 高数倍的性能。&lt;/p&gt;
&lt;p&gt;我写程序啊，不喜欢从头写。哪怕是单片机。
总不能用汇编代码一点一点写吧。再说，汇编我也只知道8051的汇编，不懂 esp32 的汇编。&lt;/p&gt;
&lt;p&gt;所以，用了 SimpleFOC 这个库。&lt;/p&gt;
&lt;p&gt;这个库虽然是用来驱动无刷电机的，但是他带了一个 3PWM Driver . 我只要用他这个。&lt;/p&gt;
&lt;p&gt;起初我用 VSCODE 搭配 ExpressIDF SDK 写过 ESP32 的代码。
但是 SimpleFOC 基于 arduino 库，无法直接使用 ExpressIDF SDK。&lt;/p&gt;
&lt;p&gt;后来我就折腾用 arduino 写。发现 arduino 的编辑器不是很顺手。代码补全，语法提示就是个 0 。&lt;/p&gt;
&lt;p&gt;还是得用vscode写，结果翻阅 simplefoc 的文档发现可以用 platformio。
PlatformIO 是个 vscode 的插件。 装上它，就有了一个单片机的集成开发环境了。
编辑器还是用的 vscode，还能用 clangd 进行自动完成。&lt;/p&gt;
&lt;p&gt;后来还发现 platformio 更高级的功能，就是可以多平台构建。可以同一份源码直接编译出 ESP32 和 STM32 的固件。
虽然soc各有不同的地方， 但是这些不同的地方可以用偶这个C++程序员最擅长的条件编译搞定。&lt;/p&gt;
&lt;p&gt;至于 stm32 的板子，嘿嘿， 之前玩电机的是买过一个 VESC 的电机控制器。控制器上是个 STM32F405G ，而且，板子上 SWD 调试端口。接上 stlink， 在 platformio 里添加一个 stm32 的板子， 点 upload 直接成功！&lt;/p&gt;</description>
    </item>
    <item>
      <title>宗门设定</title>
      <link>https://microcai.org/2022/10/20/zongmeng.html</link>
      <pubDate>Thu, 20 Oct 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/10/20/zongmeng.html</guid>
      <description>&lt;p&gt;所有的修仙小说里, 都有宗门的设定.&lt;/p&gt;
&lt;p&gt;修仙有两种途径, 或散修, 或投靠宗门.&lt;/p&gt;
&lt;p&gt;投靠宗门修仙, 宗门提供修炼资源.
投靠的方式, 主要就是给宗门当弟子.&lt;/p&gt;
&lt;p&gt;弟子这个设定, 大家会想到学校. 其实弟子不是学生.
学生到学校学习, 是要交学费的.
而弟子拜入宗门, 并不需要交学费. 不仅不交学费, 宗门还要花资源大力培养弟子.
弟子一般都是在宗门管辖区域内, 通过各种办法从凡人里招来. 所以说凡人是修士的根.&lt;/p&gt;
&lt;p&gt;招了弟子, 就得管吃管喝, 还得提供丹药之类的修炼资源, 宗门看似是在做亏本生意.
其实, 弟子是士兵. 而且是廉价炮灰. 因为支付的军饷只是可以廉价印刷的功法秘籍.
而且没有阵亡抚恤金.&lt;/p&gt;
&lt;p&gt;招收弟子, 就是招兵.&lt;/p&gt;
&lt;p&gt;有兵就要打, 因此宗门之间打来打去.&lt;/p&gt;
&lt;p&gt;有兵就要管理. 于是会分为 杂役弟子, 外门弟子, 内门弟子, 真传弟子.
管理层, 则分为 长老, 宗主.
养老的则是 太上长老, 和老祖.
杂役弟子是干杂活的, 不需要有修炼资质. 宗门只要花少量的代价, 其实就是提供食宿就嫖到的廉价劳动力.
因为穷苦百姓很多吃饭都有困难活不下去.&lt;/p&gt;
&lt;p&gt;外门弟子就需要有修炼资质了. 宗门要花的代价, 就是提供稍微高级点的食宿条件, 外加批量印刷的低级功法.
就能嫖到廉价的炮灰了.&lt;/p&gt;
&lt;p&gt;外门弟子是宗门之间战争的主力炮灰. 经常死掉一大片. 哦不对, 在修仙世界不能叫死, 得叫陨落.
外门弟子是没有特定的师父的. 宗门有专门给外门弟子讲课的人, 叫传法长老.&lt;/p&gt;
&lt;p&gt;内门弟子, 是接班人预备队. 内门弟子就有特定的师父了. 其中优秀的会成为下一代的长老们.&lt;/p&gt;
&lt;p&gt;真传弟子就是宗主亲收的弟子了. 这些可不再是炮灰了, 而是重点保护的对象了.&lt;/p&gt;</description>
    </item>
    <item>
      <title>科学与修仙</title>
      <link>https://microcai.org/2022/09/19/xiuxian.html</link>
      <pubDate>Mon, 19 Sep 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/09/19/xiuxian.html</guid>
      <description>&lt;p&gt;修仙其实和量子力学密不可分, 是有科学依据的.&lt;/p&gt;
&lt;p&gt;灵气: 灵气其实就是富含氘的空气.
灵水: 灵水就是氘的水.&lt;/p&gt;
&lt;p&gt;灵根: 为何无灵根无法修炼? 因为灵根其实就是一种特殊的线粒体. 普通的线粒体, 是燃烧葡萄糖, 参与碳循环. 而灵根, 是核动力线粒体. 只要吸收灵气就能给细胞供能.&lt;/p&gt;
&lt;p&gt;辟谷: 拥有灵根的人, 修炼到一定境界后, 就可以只依靠灵气存活了. 说明身体的核动力功能完全激活了.&lt;/p&gt;
&lt;p&gt;无垢体: 特殊体质, 其实是指身体没有传统线粒体. 不参与碳循环, 自然不会产生二氧化碳, 不需要进食. 不进食就不会产生排泄需求, 也就是无垢. 完全依靠核动力存活. 是修炼的无上体质.&lt;/p&gt;
&lt;p&gt;法力: 其实就是超能力. 而超能力其实是宏观上的量子叠加态定向坍塌. 也就是俗称的因果律武器. 最次等的因果律武器, 只能干涉单个的量子的坍塌, 在科学界, 只有三体人掌握了这个技术.
而高级的因果律武器, 可以对大量的粒子整齐的干涉到指定塌陷状态, 于是得到宏观上的&amp;quot;超能力&amp;quot;.&lt;/p&gt;
&lt;p&gt;以身合道: 对整个宇宙只能施展一次的法则, 在科学侧的含义就是确定宇宙常数. 在鸿钧以身和道前, 宇宙常数是处于量子叠加态, 是随机的. 所以说先有鸿钧后有天.&lt;/p&gt;
&lt;p&gt;修为等级: 分法力等级和法术等级. 法力等级, 指修仙者能调动的能量的大小. 由身体的等级决定. 法术等级, 是对宏观世界的干涩能力, 由施展的术法决定.
高等级的功法修炼难度也高. 是因为法术其实是一种因果律武器, 需要调动大量的神识去微操, 干涉大量的量子波坍塌才能实现. 因此修仙者需要修炼灵魂, 也就是让自己成为超级观察者, 而具体的干涉又需要能量, 因此需要
锻炼肉身, 提高线粒体的功率.&lt;/p&gt;
&lt;p&gt;到圣人这个等级, 神识已经可以对全宇宙微操, 自身可以调动整个宇宙的能量了. 所以圣人之下皆为蝼蚁.&lt;/p&gt;</description>
    </item>
    <item>
      <title>准葛尔</title>
      <link>https://microcai.org/2022/07/16/zge.html</link>
      <pubDate>Sat, 16 Jul 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/07/16/zge.html</guid>
      <description>&lt;p&gt;走新藏线前, 在叶城待了几天. 在叶城待的时候, 就很好奇叶城名字的由来.&lt;/p&gt;
&lt;p&gt;叶城, 得名的原因是叶尔羌汗国的都城. 叶尔羌汗国, 既然是叫汗国, 那肯定是蒙古人的国家了. 可是我在叶城, 发现居民大多数是维吾尔人.
维吾尔人可不搞汗国, 即便要搞也是哈里发.&lt;/p&gt;
&lt;p&gt;叶尔羌汗国的灭亡时间也很早, 在明朝中期就灭亡了. 灭亡原因不详.&lt;/p&gt;
&lt;p&gt;新疆还有蒙古自治州.&lt;/p&gt;
&lt;p&gt;给我一种感觉, 新疆原先是蒙古人的天下, 后来被维吾尔人鸠占鹊巢.&lt;/p&gt;
&lt;p&gt;回到内地后, 再去研究了新疆未回归中国前的历史, 才明白过来一些事情.&lt;/p&gt;
&lt;p&gt;满蒙联盟果然是忽悠人的. 满人的民族政策就是消灭蒙古人.&lt;/p&gt;
&lt;p&gt;准葛尔, 是继匈奴之后, 对中原威胁最大的游牧民族. 终明一朝, 始终无法解决北方边患. 土木堡之变还成了大明由盛转衰的转折点.&lt;/p&gt;
&lt;p&gt;清灭明后, 准葛尔就成了清的心头之患.&lt;/p&gt;
&lt;p&gt;清灭蒙古, 采取的是拉一波打一波的方式.&lt;/p&gt;
&lt;p&gt;首先拉拢的, 是内蒙人. 这个是满蒙联盟的基础.
后来加入的, 是喀尔喀蒙古, 也就是外蒙.&lt;/p&gt;
&lt;p&gt;这个外蒙啊, 是准葛尔送给清的.&lt;/p&gt;
&lt;p&gt;准葛尔征服喀尔喀的过程, 把喀尔喀推向了清.&lt;/p&gt;
&lt;p&gt;由于北元投降了清, 所以清获得了整个蒙古部落的法统. 但是, 这个法统属于地图开疆. 服清的, 只有黄金家族所在的内蒙.
剩下的, 要么后续拉拢, 要么消灭.&lt;/p&gt;
&lt;p&gt;而准葛尔, 就属于要消灭的那部分.&lt;/p&gt;
&lt;p&gt;清和准葛尔, 明和准葛尔, 都打了上百年的战争.&lt;/p&gt;
&lt;p&gt;最终, 游牧民族耗不过农耕民族, 失败了.&lt;/p&gt;
&lt;p&gt;准葛尔也终于从汗国变成了盆地.&lt;/p&gt;
&lt;p&gt;但是清的民族政策, 后患无穷. 清把西域变成了无人区. 直接屠灭了准葛尔.
还不移民实边, 怕汉人占了新疆又搞事.&lt;/p&gt;
&lt;p&gt;结果, 这地方水草丰美, 你不让内地人来, 别人就不来了吗?&lt;/p&gt;</description>
    </item>
    <item>
      <title>什么是汉人</title>
      <link>https://microcai.org/2022/06/04/what-is-han.html</link>
      <pubDate>Sat, 04 Jun 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/06/04/what-is-han.html</guid>
      <description>&lt;p&gt;汉人这个称呼古已有之. 但是, 内涵发生了巨大的变化, 然后被歪曲. 现在的含义对华夏人伤害非常大.&lt;/p&gt;
&lt;p&gt;汉人的最初意思, 就是汉国人. 这个也是秦人, 唐人, 宋人的含义. 就是这个国家的国民.&lt;/p&gt;
&lt;p&gt;到元代的时候, 因为蒙古人的种姓制度, 元人无法称元人了. 也就是, 元人这个称呼居然不存在了.
为了他自己的统治长治久安, 他就很随意的把人群进行划分, 分了 蒙古人, 色目人, 汉人, 南人.&lt;/p&gt;
&lt;p&gt;注意, 此时的汉人, 其实指先于南宋被统治的金人.&lt;/p&gt;
&lt;p&gt;后来朱元璋北伐灭元. 建立明朝后, 按习惯, 明朝人应该自称明人.&lt;/p&gt;
&lt;p&gt;但是, 朱元璋却搞起了汉人称呼. 于是 明朝人不自称明人, 而是自称汉人.&lt;/p&gt;
&lt;p&gt;于是这个汉人称呼才定了下来, 延续到现在. 所以现在的汉族, 其实就是原来明的国民的意思.&lt;/p&gt;
&lt;p&gt;这并不意味着, 没被明朝统治的东北人, 就不是汉人了. 他们只是不是明人, 于是不自称汉人.&lt;/p&gt;
&lt;p&gt;东北人入关后, 为了维持自己的阶级, 把阶级矛盾转成民族矛盾. 于是没有按以往的惯例, 把自己的国民称清人.
而是划分了5个民族. 满蒙汉回藏. 还把人口最多的人踩脚底下.&lt;/p&gt;
&lt;p&gt;而汉人, 就是指原来的明人.&lt;/p&gt;
&lt;p&gt;此时的汉人, 其实并不是西方意义上的民族的称呼. 而是东方语境下的民族.&lt;/p&gt;
&lt;p&gt;直到民国, 我们学习了西方的技术, 同时也把西方的民族观舶来了. 于是把清朝时划分的汉人, 给整出了一个 汉族人的概念.&lt;/p&gt;
&lt;p&gt;孙中山还没发现自己其实被西方文化坑了, 其实, 如果他要反清复汉, 其实就是只能恢复到明朝的版图. 因为汉人其实就是按明人划分的.
于是他匆匆改口, 搞了五族共和.&lt;/p&gt;</description>
    </item>
    <item>
      <title>不恰饭的车评人危害性更大</title>
      <link>https://microcai.org/2022/06/03/harmfull-chepingren.html</link>
      <pubDate>Fri, 03 Jun 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/06/03/harmfull-chepingren.html</guid>
      <description>&lt;p&gt;端午节前，汽车界最大的瓜，就是叶问大战38号。&lt;/p&gt;
&lt;p&gt;首先介绍一下事情的来龙去脉&lt;/p&gt;
&lt;p&gt;&lt;em&gt;事情的起因是教主（本名鲁超，自封键盘车神教的教主，以下简称教主）测试领克的时候，被奇瑞的粉丝要求也测一下新发布的凌云S，因为奇瑞宣传这个是赛道级的车。
教主他走的是车评中的细分行业，就是只评家用赛车。在这个细分领域有大量的粉丝。一般的车他还不测，只测那种能下赛道的贵族车。但是他居然测了平民车领克，领克是家用车啊。所以粉丝要求他也测奇瑞的车，并不过分。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;于是他就按他的理解，把奇瑞当成那种贵族的赛车，在赛道上霍霍了一下，果然纯家用的属性就暴露了。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;到这个时候还好，也就是一个小插曲，一个只玩贵族车的人突然一反常态的测了一下屌丝车，然后得出屌丝车下不了赛道的结论。然后成为他粉丝的笑谈。什么垃圾奇瑞也想下赛道之类的云云，在粉丝里充满了快活的空气。节目效果也有了。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;但是，奇瑞的粉丝炸锅了，不服气，他们买的车被教主鄙视，能服气吗？顺带着另一个给奇瑞站台的车评人郑刚也批评教主，形成了一方锤教主的势力。教主气不过啊，被人一挑拨，一怒之下自己买一辆。被人喷，就得怼回去。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;结果不重测还好，一重测问题更大了。这成绩比原来借来的车更差了。教主公然放出量产车只有7.6s的成绩，奇瑞虚假宣传的话。不服来北京测，能跑6.2s车送给你。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;这种小孩子般约架的话，能有个俅用。于是被郑刚继续追着撕咬。眼看自己招架不住，他想到了自己的好朋友，38号。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;这下事情就进入了无可挽回的地步了。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;教主做的是赛车这种细分市场，而38做的，是几乎所有的车的市场。38下场为教主站台，等于乌克兰冲突后美国直接下场。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;都不是一个级别的对线了。这时候，叶问（本名朱殿举，网名叶问讲高考志愿，简称叶问）来锤38号了。叶问这个人，他很早就说，车评人屁股歪，不为国产车叫好，只给合资车站台，他要捶死这个车评行业。当年出道就先捶死了 yyp，yyp 以发一期夸奖 汉DMI 的视频投降。这次 38号 居然想奇瑞死，叶问能不出手？于是叶问下场。战争升级。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;叶问打车评人第一步，首先质疑7.6s成绩是故意抹黑。他自己找公司的一个女员工测了一下，是7.2s。明明能跑的比7.6s更快，却故意测出来 7.6s，是何居心？然后抖出大瓜，说38之前黑凡尔赛的时候敲诈了神龙公司200万。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;教主这边则是以他白天测7.6s，晚上测能到7.3s，但是无论如何测不到 7s 来回应。并指出奇瑞自己的宣传视频里，6.0s 的成绩是P图造假。然后他的粉丝就进入了嘲讽陶腾飞造假的潮吹，充满了快活的气息。（陶鹏飞就是帮奇瑞跑出6.0s成绩的车手）并纷纷心疼教主被陶鹏飞用时间系魔法骗走了18万。其中也不乏帮领克跑 WTCR 的车手，也开启了嘲讽陶鹏飞的盛宴。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;公然造假，奇瑞这下是要吃官司了。教主作为车主起诉是必胜啊，退一赔三，买车钱是肯定有着落了。所以其实粉丝是不用心疼的。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;而 38 的回应则是解释了自己为何只能测到7.6s, 因为成绩受各种因素影响，并且辩解自己并没有说奇瑞只能跑7.6s。然后还辩解自己没有只夸合资车，国产车也夸了。然后就200万敲诈回应，你没证据就是造谣。我悬赏400万求证据。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;此时教主还来嘲讽叶问智商，并表示200w敲诈这种黑料，就是他卧底叶问的群提供的。于是他的粉丝又进入了嘲讽叶问相信敌人的假冒黑料智商垃圾的群体高潮。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;由于 38 的粉丝笃信叶问被教主耍了，于是纷纷跑去在叶问的视频里留言喷他。
一股胜券在握的胜利者姿态。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;于是叶问微微的掉了一些粉。一些讨厌38但是又不好支持叶问的人，都开启了“中立” 模式。因为不能支持一个智商不在线的人，对吧？而且38的粉丝威胁站叶问就是支持奇瑞造假，罪无可赦。车评圈的其他大V们，则是全部下场，几乎全部站队38， 批判奇瑞造假. 像11磅小老虎直接说，谁不站38的都把我拉黑了吧。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;好家伙，好家伙。一边是几乎全体车评人站队38，少数开启中立模式。另一边是叶问的视频下面被嘲讽和劝降的言论刷屏。而中立的人，日子也不好过，因为38的粉丝拿出奇瑞造假的证据，逼他们站38，必须站38. 颇有饭圈的味道。这波啊，38用不能支持企业造假的政治正确，绑架了几乎所有人一起集火叶问。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;连讲叶问打拳影视作品的视频下面，都被要求站队38，你敢信？&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;叶问死定了。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;这瓜越来越大了。在6月1号当天，叶问再次发视频。并给出了38号雇佣水军冲击他的视频评论区的证据。等等，合着之前他视频下一边倒的言论是水军？&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;紧接着马上发第二个视频，向38提出了灵魂质问：你是不是富二代？你恰饭你的钱哪里来的？有没有接受日本外务省的资助？怎么解释以前为日本侵华洗地的言论？&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;并且他发视频，等水军冲完后，将视频删了重发（等于清空评论）。这波啊，如果水军重发贴子，他可以继续删视频然后重发。看你雇佣水军的钱多，还是我重发的钱多。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;果然几次重发后，水军数量大幅减少。于是他的视频下面终于可以看到真正的吃瓜群众的留言了。群众还是吃瓜，并不站38，也不站叶问，更没有人站奇瑞，只是吃瓜看戏。真正的群众怎么会因为奇瑞造假去冲叶问的视频么？吃瓜看戏才是天朝人民的秉性。只不过吃瓜群众还是被人追问，承不承认奇瑞造假？&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;38的粉丝炸锅了！他们炸锅并不是突然发现自己粉的对象有特务嫌疑，而是发现叶问居然不讲事实，不讲证据，居然直接上升到国家安全层面攻击38. 你不讲武德！你无耻，你卑鄙。你下流！你拿奇瑞跑不出6.0s你就是输了，你要退网！讨论奇瑞有没有造假的话题你不能岔开！&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;而原来站38的大人物突然沉默。事情明朗前还是先沉默。只有38的粉丝开始疯狂的输出叶问不讲武德，卑鄙下贱的言论。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;此时一些中立的人，开始表达38其实非常双标，真的很怀疑是不是日本派来的。而且表示38根本不可能不恰饭。但是仍然表示不叶问以防水军冲击。38以前评车时非常双标的言论被扒了出来。而粉丝还在为38战队，连 即便38真的是特务，也不能否定奇瑞造假 这样的失智言论都开始疯狂输出。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;球来到了38这边。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;38 在人设问题上投降，承认自己不是富二代，钱来自懂车帝，没有收车企的钱。表示懂车帝给的钱比车企还多，看不上车企的钱。承认自己去过日本搞“学术交流”，但是是学术交流，不是参加汉奸培训班。然后再次要求叶问拿出证据，不然走着瞧！&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;截止到我写作时间（北京时间6月3好凌晨3点）叶问尚未回应。&lt;/p&gt;
&lt;p&gt;好了。事情的来龙去脉搞清楚了，我来说说我的看法。&lt;/p&gt;
&lt;p&gt;我认为，不恰饭但是立场偏向国外品牌的车评人，对国家危害更大。&lt;/p&gt;
&lt;p&gt;首先，凡是媒体，必有立场。无立场的最好做法是不发表言论。凡是发表了言论还说自己的言论是理性客观中立的，那一定是诈骗。这个立场是说他内心的立场，不是说他发出来的东西的立场。
因为有立场，不表示他一定会说这个立场。因为很多时候人要说违心的话。“他给的太多了”&lt;/p&gt;
&lt;p&gt;于是我把车评人分三种。&lt;/p&gt;
&lt;p&gt;第一类，粉丝不多，完全看不出立场。你能看到的是，他的立场变来变去。有钱就是爷。
第二类，头部大V，粉丝众多。他的立场号称理中客，实际被看到的会有些许偏移，但不明显。偏移情况主要看金主的钱。但是给再多的钱也不能进一步解锁他的立场。不然沦为第一类了。承认恰饭，但是表示恰饭不影响他的立场。
第三类，就是38为代表，已经形成一个教派。完全拒绝充值。&lt;/p&gt;
&lt;p&gt;第一类和第二类车评人，他们的立场是可以用金钱收买的。
无非就是收买车评人的成本，最终要消费者承担。&lt;/p&gt;
&lt;p&gt;但是，不管是自主品牌还是合资品牌，他们其实面对的是相同的敲诈环境。
也就是说，虽然老百姓多花钱供养了车评人，但是自主和合资面对的勒索力度是一样的。
大家公平竞争。谁撒的狗粮多，谁赢。&lt;/p&gt;</description>
    </item>
    <item>
      <title>民族? 屁!</title>
      <link>https://microcai.org/2022/05/29/mingzugepi.html</link>
      <pubDate>Sun, 29 May 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/05/29/mingzugepi.html</guid>
      <description>&lt;p&gt;由乌克兰和俄罗斯火併想到了一个故事.&lt;/p&gt;
&lt;p&gt;我是微菜, 我生活在南方崇山峻岭里, 从小就喜欢看动画片.
有一年, 我造反了. 我找了一群志同道合的同乡, 打出了消灭电视剧的口号.
因为我们是动画人. 广电他总是不让我们好好的看片.&lt;/p&gt;
&lt;p&gt;我们割据一方, 和中央对峙好多年. 为了加强我们自己人相互之间的认同, 我们发明了动画人概念, 创造了动画字, 以南方某方言为范本发明了动画语.
我们以后都说动画语, 写动画字, 是动画人. 谁要还写汉字, 就是叛徒, 是中央派来的奸细.&lt;/p&gt;
&lt;p&gt;最终, 中央因为腐败倒台了, 我们乘机杀入北京, 建立了动画国.&lt;/p&gt;
&lt;p&gt;为了维持我们的地位, 我们要求所有人都只能看动画片. 谁要看电视剧, 就杀.&lt;/p&gt;
&lt;p&gt;而我们动画人, 从此可以不用干活, 天天窝家里看动画片了. 国家高级职位只能动画人担任.&lt;/p&gt;
&lt;p&gt;但是, 我担心以后会出事情, 于是在各地建动画城, 不让普通动画人出城. 生怕某个动画人搞事情, 又要建国.&lt;/p&gt;
&lt;p&gt;为了更好的治理国家, 我们动画人就推广了北京话. 因为大家都会说. 但是要求动画人必须得学动画语. 不能忘本啊.&lt;/p&gt;
&lt;p&gt;就这么过去了百来年.&lt;/p&gt;
&lt;p&gt;动画国最终还是因为腐败被推翻了. 动画人一夜之间消失了.&lt;/p&gt;
&lt;p&gt;后面的几任领导, 居然连动画语都不会说, 不会写, 太不像话了!&lt;/p&gt;
&lt;p&gt;后来, 新的国家建立了很多年后. 为了民族团结, 不要大家喊打喊杀了. 说少数民族加分加分. 新的国家还包括越南, 朝鲜.
其实这些国家是动画国好大喜功搞进来的. 当然其实也用了一些自古以来. 新国家自然要继承动画国的原有地盘, 不能把这些人分出去.&lt;/p&gt;
&lt;p&gt;结果动画人一夜之间又多起来了. 很多人纷纷表示他以前其实是动画人. 虽然这些人并不会说动画语.&lt;/p&gt;
&lt;p&gt;突然有一天, 越南人说, 几百年前我们越南人和老共国互动频繁, 你们讲的都是动画语. 真正的北京话在我们越南. 我们都是两山轮战的解放军人后代.&lt;/p&gt;</description>
    </item>
    <item>
      <title>普通话就是古汉语活化石</title>
      <link>https://microcai.org/2022/05/10/yayan.html</link>
      <pubDate>Tue, 10 May 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/05/10/yayan.html</guid>
      <description>&lt;p&gt;我是南方人, 从小在学校学习普通话. 平时大家基本上都以普通话交流. 因为温州这个地方, 连跨个村都能换一个方言.
根本就没有能主宰当地的强势方言, 如果有, 那只能是普通话.&lt;/p&gt;
&lt;p&gt;后来因为家庭缘故, 中学时代远去了河南度过.&lt;/p&gt;
&lt;p&gt;河南这个地方, 大家都说河南话, 不说普通话.
只不过, 河南话和普通话, 并没有太大差异. 语音语调略有差异, 类似唱歌跑调.
家中也常来山东大汉做客. 操着山东话和父亲谈生意.&lt;/p&gt;
&lt;p&gt;山东话和河南话也是非常接近. 不熟之人也不太能分别.&lt;/p&gt;
&lt;p&gt;小学时候, 以为的方言就是各种鸟语. 大家鸟语不通, 于是用通用的普通话.
去到北方, 才真切的感受到, 只是南方的方言是鸟语.
北方的方言, 大体还是同一种语言略有差异.&lt;/p&gt;
&lt;p&gt;不过, 也正因为如此, 北方人对普通话就不重视. 这点就让我非常讨厌北方人. 就因为天生母语接近普通话, 就直接不学普通话了事.
难怪经济不发达, 人太懒了.&lt;/p&gt;
&lt;p&gt;到读大学, 又回南方跑去杭州. 又变成了方言大杂烩, 各自听不懂的状态. 于是大家又说普通话了.&lt;/p&gt;
&lt;p&gt;还是普通话好, 消灭方言, 人才能顺利沟通, 消除隔阂.&lt;/p&gt;
&lt;p&gt;但是, 人进了大学, 就容易变成脑残. 自以为高人一等, 学的都是先进知识. 把老人都批判一番. 我进了大学也不能免俗. 我在大学里学到的最重要的知识, 就是64事件.
所谓人一独, 脑就残. 总觉得墙外的信息才是真实信息. 对洋人和殖畜的话是奉为圭臬. 于是对自己的语言都开始了怀疑.&lt;/p&gt;
&lt;p&gt;于是, 那时候我相信, 北方话是胡人的话, 真正的汉语已经消亡了. 要算最接近老祖宗的汉语的, 就属粤语了.&lt;/p&gt;
&lt;p&gt;其实我已经中了陷阱而不自知.&lt;/p&gt;
&lt;p&gt;数年前, 老爹带我去参加了宗祠聚餐. 我讨厌酒文化, 所以以往我从未去过.
那一年我第一次去, 老爸人肉导航指挥我开车数小时到了一处偏僻的山脚下一座小村子.
老爹说, 我们这一系的宗祠就在这里了.&lt;/p&gt;</description>
    </item>
    <item>
      <title>FEC VPN</title>
      <link>https://microcai.org/2022/04/29/new-vpn.html</link>
      <pubDate>Fri, 29 Apr 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/04/29/new-vpn.html</guid>
      <description>&lt;p&gt;给大家推荐一个好用的 VPN 软件. 可以在恶劣的环境中为其上承载的网络提供稳定的保障.&lt;/p&gt;
&lt;p&gt;这个 VPN 的诞生缘由, 大概经历了3个时段.&lt;/p&gt;
&lt;p&gt;第一个时段, 我折腾使用了 &lt;a href=&#34;https://github.com/wangyu-/tinyfecVPN&#34;&gt;tinyfecVPN&lt;/a&gt;, 虽然用起来颇为不便, 但好在比 openvpn 要稳的多.
于是推荐给了隔壁老王.&lt;/p&gt;
&lt;p&gt;老王发现这个 tinyfecVPN 代码质量略渣. 但是前先纠错的理念不错. 但是他目前用不到 vpn, 于是冇行动, 冇用起来.&lt;/p&gt;
&lt;p&gt;过了一阵子, 老板又双叒叕脑洞瞎开, 要开发一个比 &lt;a href=&#34;https://www.resilio.com/&#34;&gt;btsync&lt;/a&gt; 还要牛逼的同步软件放他的 NAS 产品上用.
他要把数据拆分成 N 份, 然后存储 M 份到不同的NAS上. 只要在线的NAS数量足够, 数据就可以完全恢复.&lt;/p&gt;
&lt;p&gt;于是老王想到了 tinyfecVPN 的理念, 用上了 FEC 纠错的方法.&lt;/p&gt;
&lt;p&gt;写了一个 FEC 分片工具. 把指定的文件先分片, 然后用 FEC 算法添加冗余纠错. 然后形成大量的冗余分片. 丢失一些分片还可以完整复原整个文件.&lt;/p&gt;
&lt;p&gt;然后进入第三个时段. 老板要他的 NAS 尽可能的保持在线数量. 但是有一些西南边区的用户买过去, 他网络状况就不怎么好, 丢包率有那么一点点高.
并不是说边区的人民网络差, 他们访问互联网大厂的CDN并不慢,也不丢包, 而是这些NAS要 P2P, nas和nas之间p2p的时候, 丢包率有那么一点点高.&lt;/p&gt;
&lt;p&gt;于是老王决定, 写一个基于 FEC 算法的 VPN, 然后老板的 nas 通过这个 VPN 组网, 就解决 p2p 丢包导致的网络问题了.
至于不直接用 tinyfecVPN, 那当然是没法用啊.&lt;/p&gt;</description>
    </item>
    <item>
      <title>异构容器</title>
      <link>https://microcai.org/2022/04/26/hybrid-container.html</link>
      <pubDate>Tue, 26 Apr 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/04/26/hybrid-container.html</guid>
      <description>&lt;h1 id=&#34;路由器-引起的&#34;&gt;路由器 引起的&lt;/h1&gt;
&lt;p&gt;路由器，基本上都是MIPS处理器。
而 PC，那铁定是 AMD64 的处理器。&lt;/p&gt;
&lt;p&gt;因此，绝无可能把 PC 上的程序直接拷到路由器里跑。&lt;/p&gt;
&lt;p&gt;因为 glibc 特有的 ABI 问题，也不能直接交叉编译。&lt;/p&gt;
&lt;p&gt;gentoo 的 crossdev 工具虽然能方便的生成交叉工具链，但是编译出来的程序，放到路由器上还是会报告 glibc 的符号版本问题。&lt;/p&gt;
&lt;p&gt;因此，我用 qemu 运行了一个 mips 的虚拟机，然后在虚拟机里编译。虚拟机里安装和 路由器相同的 os - Debian 9 MIPS。&lt;/p&gt;
&lt;h1 id=&#34;systemd-nspawn--qemu_user&#34;&gt;systemd-nspawn + qemu_user&lt;/h1&gt;
&lt;p&gt;一个虚拟机要如何运行呢？第一考虑是 qemu 运行一个 mips 虚拟机。&lt;/p&gt;
&lt;p&gt;然而我这次是使用 &lt;a href=&#34;https://microcai.org/2011/04/26/chrootarm.html&#34;&gt;十年前曾提过的 技术&lt;/a&gt;。只不过，当年使用的是 chroot。
如今我重拾这个技术，并对 chroot 做一个升级，使用 systemd-nspawn 进行更高级的 chroot。&lt;/p&gt;
&lt;p&gt;于是，新型虚拟机就诞生了。为啥当年 chroot + qemu_user 我不叫他虚拟机呢？
当然是因为 chroot 太原始了。而 systemd-nspawn 隔离的东西就更多了。网络也可以独立起来。&lt;/p&gt;</description>
    </item>
    <item>
      <title>各种各样的混动</title>
      <link>https://microcai.org/2022/04/21/hybrids.html</link>
      <pubDate>Thu, 21 Apr 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/04/21/hybrids.html</guid>
      <description>&lt;h1 id=&#34;混动怎么个混法&#34;&gt;混动怎么个混法?&lt;/h1&gt;
&lt;p&gt;混动混动, 就是发动机和电动机一起干活.&lt;/p&gt;
&lt;p&gt;一起干活, 配合的姿势就有很多种. 具体的搭配方法, 有2大方向: 机械分流, 电子分流.&lt;/p&gt;
&lt;h2 id=&#34;电子分流&#34;&gt;电子分流&lt;/h2&gt;
&lt;p&gt;先说电子分流. 因为这个概念上好理解. 就是一个电机发电, 另一个电机驱动. 发动机的动力全部输出给发电机, 发电机的出力, 分流一部分给电池. 所以叫电子分流.&lt;/p&gt;
&lt;p&gt;电子分流利用的就是电池巨大的缓冲能力, 以及电子控制器迅速的调节能力.&lt;/p&gt;
&lt;p&gt;整车实际上是实现了一个微电网. 负荷是驱动电机. 电池为一次调峰电厂, 发动机为二次调峰电厂.&lt;/p&gt;
&lt;p&gt;驱动电机负荷变化后, 首先由电池承担一次调峰任务, 立即改变充电(or 放电)功率, 以平衡发电. 然后再缓慢调节发动机的功率.&lt;/p&gt;
&lt;p&gt;那么, 电池越大, 调节能力越强, 就越能长期保持发动机运行在高效工况上.&lt;/p&gt;
&lt;p&gt;电子分流要玩的转, 首先需要强大的电力电子技术. 要能玩的转微电网.&lt;/p&gt;
&lt;p&gt;然后, 这个微电网, 其实还分 直流电网/交流电网 两种.&lt;/p&gt;
&lt;p&gt;只不过, 目前市面上并不存在使用交流电网的混动车.&lt;/p&gt;
&lt;p&gt;但实际上是可行的. 尤其是驱动电机使用三相交流异步电机的话, 是可以使用交流电网的.
那么电池作为一次调峰电厂, 就需要并网逆变器. 并且在车速变化的时候, 采取整体改变电网频率的方式变频.&lt;/p&gt;
&lt;p&gt;交流电网适合驱动功率和发电功率相当的情况. 发电机的电力直接输出给驱动电机, 中间不经过整流逆变环节, 能大大提高效率. 但是如果驱动功率和发电功率差异较大, 则需要并网储能逆变器
多多工作, 这里的整流逆变将损失较多能量.&lt;/p&gt;
&lt;p&gt;电子分流的缺点是发电再用电的环节存在效率损失. 但是只要这个损失小于发动机和车轮解耦后带来的效率提升,就是值得的.&lt;/p&gt;
&lt;p&gt;但是, 在高速上, 传统油车的发动机也进入了高效工况, 于是这个中间的转换损失就会大于效率提升.&lt;/p&gt;
&lt;p&gt;因此纯粹的电子分流, 在高速上效率可能会低于传统的油车. 具体低多少, 取决于电力电子技术的优秀程度.
当然这个比较是基于发动机的热效率差不多的情况. 实际上专门为混动开发的发动机最高热效率是会高于普通发动机的. 因此系统整体热效率在高速上可能依然是混动占优.
&lt;em&gt;比如理想one在高速上开120码油耗也低于发动机直驱的纳智捷&lt;/em&gt;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>棍勇喜欢大公主</title>
      <link>https://microcai.org/2022/04/11/%E6%A3%8D%E5%8B%87%E5%96%9C%E6%AC%A2%E5%A4%A7%E5%85%AC%E4%B8%BB.html</link>
      <pubDate>Mon, 11 Apr 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/04/11/%E6%A3%8D%E5%8B%87%E5%96%9C%E6%AC%A2%E5%A4%A7%E5%85%AC%E4%B8%BB.html</guid>
      <description>&lt;p&gt;这番完结很久了, 但是有些话不吐不快.&lt;/p&gt;
&lt;p&gt;棍勇重生后, 欺负过他的人, 他只留下了大公主活口. 不仅仅留了活口, 还一直带在身边.
不仅仅带在身边, 还不让她身处险境.&lt;/p&gt;
&lt;p&gt;因为棍勇是非常喜欢大公主的.&lt;/p&gt;
&lt;p&gt;有很多人因为一周目的时候大公主虐待棍勇, 就认为棍勇不喜欢大公主, 仇恨大公主. 这个是不对的.&lt;/p&gt;
&lt;p&gt;炮勇和剑勇都虐待过棍勇. 二周目的时候, 棍勇对他们就没心慈手软过.&lt;/p&gt;
&lt;p&gt;反而对待大公主, 棍勇心软了. 棍勇要等大公主虐待他, 才复仇. 因为他从心底也渴望世界线的变动. 希望二周目的大公主是表里如一的人.
如果大公主在二周目的时候突然改了, 棍勇其实就很乐呵呵的继续待大公主边上了.&lt;/p&gt;
&lt;p&gt;即使大公主一如一周目一样开始虐待他, 他也没想杀了大公主复仇. 而是将她洗脑易容, 给她第二生命.&lt;/p&gt;
&lt;p&gt;后来在遇到剑勇的时候, 棍勇宁可自己女装去刺杀剑勇. 他也想过让大公主去接近剑勇, 但是他为什么最终还是决定自己女装上阵呢?
首先, 他怕大公主遇到危险. 其次, 他知道剑勇喜欢大公主, 他吃醋. 他对观众解释自己亲自出马是怕大公主搞不定, 任务失败.&lt;/p&gt;
&lt;p&gt;那不过是他自欺欺人罢了. 大公主也是王国第一勇者, 怎么会打不过老三, 而且还是在偷袭状态下.&lt;/p&gt;
&lt;p&gt;那么大公主喜欢不喜欢棍勇呢?&lt;/p&gt;
&lt;p&gt;大公主既喜欢棍勇, 又不喜欢棍勇. 她不喜欢棍勇主要是因为棍勇无能. 不能帮助她的除魔大业. 然后就是她自视清高, 不喜欢下等人.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;但是, 不喜欢下等人这点是装的. 二公主曾经说她姐姐把亚人当虫子, 但是鹰眼否认说大公主不是这种人&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;但是她又喜欢棍勇, 是因为他们勇者4人行的队伍, 只有棍勇能安慰她. 大公主是勇者, 更是女人啊. 白天打累了, 晚上需要有人安慰.&lt;/p&gt;
&lt;p&gt;他们一共就4个人, 晚上该找谁不言而喻. 剑勇虽然喜欢大公主, 但是大公主是谁? 她需要的是可以被她喜欢的男宠, 而不是喜欢她的女人.
大公主厌恶棍勇, 厌恶他的无能, 厌恶他的出身.
但是大公主又喜欢棍勇, 她喜欢棍勇的美貌, 她喜欢棍勇可以作为宠物一般的把玩.&lt;/p&gt;</description>
    </item>
    <item>
      <title>武器很贵</title>
      <link>https://microcai.org/2022/04/01/weapon-is-costy.html</link>
      <pubDate>Fri, 01 Apr 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/04/01/weapon-is-costy.html</guid>
      <description>&lt;p&gt;俄罗斯和乌克兰打了一个多月了.&lt;/p&gt;
&lt;p&gt;消耗了不计其数的武器和人命.&lt;/p&gt;
&lt;p&gt;战争就是烧钱, 谁先烧完, 谁就得投降.&lt;/p&gt;
&lt;p&gt;因为, 武器是很贵很贵的. 一发导弹能解决的事情, 俄罗斯非要派地面部队填人命的方法去打. 无他, 武器太贵了. 武器比人命要贵的多, 而且是多得多.&lt;/p&gt;
&lt;p&gt;交战双方的战报, 都是 击落敌机 多少架, 击沉战舰多少艘, 击毁坦克多少辆.
至于交战的士兵死了几个, 好像就没有那么在意了.&lt;/p&gt;
&lt;p&gt;武器太贵了!&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;听人常说, 要拿起法律的武器保护自己. 要用法律维权.
法律是武器没假, 但是他们不会告诉你, 法律这个武器, 非常的贵.&lt;/p&gt;
&lt;p&gt;用法律维权和战争一样, 都是烧钱, 看谁先烧完.&lt;/p&gt;
&lt;p&gt;战争让军火商发财, 用法律维权则是让律师发财.&lt;/p&gt;
&lt;p&gt;越来越贵的武器, 让富裕的国家占有了越来越大的优势.&lt;/p&gt;
&lt;p&gt;法律, 也让富人占有越来越大的优势.&lt;/p&gt;
&lt;p&gt;如果你公司账上没有可以随时冻结也不影响运转的三千万资金, 就不要用法律和腾讯斗.
如果你工资卡里没有600万, 就不要和特斯拉斗.&lt;/p&gt;
&lt;p&gt;你烧六百万, 他也烧六百万. 但是, 他有六百个亿可以烧.&lt;/p&gt;
&lt;p&gt;所以, 你选择了 &amp;ldquo;匹夫一怒 ，血溅三尺&amp;rdquo;, 富人慌了.&lt;/p&gt;
&lt;p&gt;你有一条命, 资本家&amp;hellip;好像也只有一条命.&lt;/p&gt;
&lt;p&gt;那就坐下来好好谈吧.&lt;/p&gt;
&lt;p&gt;可是如果人人效仿, 资本家还赚什么钱?&lt;/p&gt;
&lt;p&gt;所以资本家就得雇佣大量的御用水军对大众进行 PUA. 遇事不要冲动. 冲动是魔鬼. 一定要拿起法律的武器合法的保护自己的权益.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;这才是资本主义法制的真相.&lt;/em&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>键政一把</title>
      <link>https://microcai.org/2022/03/21/%E9%94%AE%E6%94%BF%E4%B8%80%E6%8A%8A.html</link>
      <pubDate>Mon, 21 Mar 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/03/21/%E9%94%AE%E6%94%BF%E4%B8%80%E6%8A%8A.html</guid>
      <description>&lt;h1 id=&#34;远交近攻是老祖宗留下的哲学&#34;&gt;远交近攻，是老祖宗留下的哲学&lt;/h1&gt;
&lt;p&gt;谁离我们远？ 欧洲，美洲。
谁离我们近？ 印度。&lt;/p&gt;
&lt;p&gt;现代中国面临的最大的威胁是什么？ 是能源安全，粮食安全。&lt;/p&gt;
&lt;p&gt;打下印度，这2个危险都解决了。&lt;/p&gt;
&lt;p&gt;有了印度洋出海口，美国所谓的岛链不攻自破。&lt;/p&gt;
&lt;p&gt;有了印度，18亿亩耕地红线就自动守住了。&lt;/p&gt;
&lt;p&gt;有了印度大陆的优质耕地，可以再多养活20亿中国人。&lt;/p&gt;
&lt;p&gt;拿下印度， 就不必与巴基斯坦友好， 就不必为了忌惮巴基斯坦而放任国内绿教兴风作浪。&lt;/p&gt;
&lt;h1 id=&#34;死掉的毛熊才是好的毛熊&#34;&gt;死掉的毛熊才是好的毛熊。&lt;/h1&gt;
&lt;p&gt;安全有了保障，就不必和俄罗斯结盟。可以继续肢解俄罗斯。拿回苏武放羊的北海。拿回库页岛。&lt;/p&gt;
&lt;p&gt;压制住俄罗斯，才能做欧洲的话事人。&lt;/p&gt;
&lt;h1 id=&#34;没有美国世界会更美&#34;&gt;没有美国世界会更美&lt;/h1&gt;
&lt;p&gt;没有美国，世界会少很多很多战争。&lt;/p&gt;
&lt;h1 id=&#34;沈万三必须死&#34;&gt;沈万三必须死&lt;/h1&gt;
&lt;p&gt;有钱人最大的罪恶就是有钱。不挣有钱人的钱，挣谁的钱？&lt;/p&gt;
&lt;p&gt;越有钱越是惜命。汤师爷说道，不能拼命啊， 拼命了还怎么挣钱。&lt;/p&gt;
&lt;p&gt;只有把资本家关进笼子，资本才能为人民做事。&lt;/p&gt;
&lt;p&gt;其实前面做的一切，其实都只是为了杀沈万三的时候，资本没有逃路，只能被关进笼子。不然资本外套，去了他国，那就只有变成了被资本家制裁了。&lt;/p&gt;
&lt;p&gt;资本无国界。但是又躲在国界的背后躲避人民的铁拳。&lt;/p&gt;
&lt;p&gt;你打它，他就跑，留下饥饿的人民。&lt;/p&gt;
&lt;p&gt;只有世界大同的时候，资本再无国界可躲，你要他进笼子，他就只能进笼子。&lt;/p&gt;</description>
    </item>
    <item>
      <title>seccomp 是个好东西</title>
      <link>https://microcai.org/2022/03/20/seccomp.html</link>
      <pubDate>Sun, 20 Mar 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/03/20/seccomp.html</guid>
      <description>&lt;style&gt;
p {
    text-align: justify;
    font-family: monospace;
}
&lt;/style&gt;
&lt;p&gt;最近在实现 git 商城的时候, 遇到了收款方面的问题.&lt;/p&gt;
&lt;p&gt;不沾钱就不用为钱相关的破事费心. 不想碰钱, 钱总得收了才能发货. 不然岂不是做慈善.&lt;/p&gt;
&lt;p&gt;所以, 我决定, 让卖家在自己的 git 仓库里放一个 js 脚本来收钱.&lt;/p&gt;
&lt;p&gt;具体的来说, 就是每当用户要支付订单的时候, js 脚本就被运行, 要求吐出一行链接. 这个链接可以让用户进行支付. 他可以是一个收款的网页, 也可以是一个能唤醒支付宝或者微信的 scheme 地址.&lt;/p&gt;
&lt;p&gt;这就要求嵌入一个 js 引擎. 但是, 试问现今写 js , 谁不是写 nodejs 呢?
但是, 嵌入一个 node 非我所愿.
我更希望的做法, 是以子进程的方式运行node, 而不是将 libnode.so 嵌入主程序.&lt;/p&gt;
&lt;p&gt;运行独立的 node 进程, 还必须让 node 可控. node 不能做一些危险操作. 这个只要不用 root 账号运行 node, node 自然是无法做危害系统安全的事情.&lt;/p&gt;
&lt;p&gt;但是, 不危害系统安全, 不等于没有危害. 即便没有 root 权限, 脚本还能挖矿, 还能偷数据, 还能当肉鸡 ddos 别人, 还能拿我们的服务器当代理.&lt;/p&gt;</description>
    </item>
    <item>
      <title>git 定义商城</title>
      <link>https://microcai.org/2022/03/06/git-based-mall.html</link>
      <pubDate>Sun, 06 Mar 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/03/06/git-based-mall.html</guid>
      <description>&lt;h1 id=&#34;引&#34;&gt;引&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;商人商人实在太伤人
你说所有人都这么看你
怨不得每一天唉声又叹气
感慨着赚钱真的不容易

其实商人就是买东西
把东边的买卖到西边去
辨贵贱 调余缺 度远近
世上不能没有我和你

急人之所急 需人之所需
这才是真正做生意
买的找不到（着）卖的 卖的找不到（着）买的
一潭死水怎会有生机
急人之所急 需人之所需
这才是真正帮了自己
一网不捞鱼 二网不捞鱼
三网就捞个大尾巴尾巴尾巴鱼
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;做买卖, 就得有铺子. 从前的铺子, 在街头.
现在的铺子, 还可以在网上.&lt;/p&gt;
&lt;p&gt;只要是个铺子, 就得有人打理.&lt;/p&gt;
&lt;p&gt;不管是格子铺, 还是架子铺. 东西都要分门别类的摆放好. 逛的人舒心了, 才会多来逛.&lt;/p&gt;
&lt;p&gt;通常网铺会提供一个在线的编辑器, 用于输入描述性的文字. 还可以设定字体,字号,颜色.&lt;/p&gt;
&lt;p&gt;还能插入图片.&lt;/p&gt;
&lt;h1 id=&#34;痛&#34;&gt;痛&lt;/h1&gt;
&lt;p&gt;图文并茂, 才能赏心悦目.&lt;/p&gt;
&lt;p&gt;编辑器可是个大工程, 何况还是在线的.&lt;/p&gt;
&lt;p&gt;于是, 编辑商品的编辑器, 就只能因繁就简了. 只能聊胜于无了.&lt;/p&gt;
&lt;p&gt;每天面对这么简陋的编辑器, 小二也觉得越来越犯2. 于是, 放截图替代了用简陋编辑器含辛茹苦的码字.&lt;/p&gt;
&lt;p&gt;看着好像是个精心排版的东西, 实际上是在其他软件上排版好, 然后截图过来的图片.&lt;/p&gt;
&lt;p&gt;编辑功能彻底成了摆设.&lt;/p&gt;
&lt;p&gt;即使是这样, 小二还嫌他传图功能都鸡肋呢!&lt;/p&gt;
&lt;p&gt;在店小二还在学习 加粗,变大,插图片 富文本三部曲的时候, 程序员也想给自己的 README 加一点点的样式.&lt;/p&gt;
&lt;p&gt;程序员可不喜欢纯靠鼠标精确点击实现的 加粗,变大,插图片 三部曲.&lt;/p&gt;
&lt;p&gt;于是 markdown 应运而生.&lt;/p&gt;</description>
    </item>
    <item>
      <title>c&#43;&#43;20 协程</title>
      <link>https://microcai.org/2022/02/20/co_await.html</link>
      <pubDate>Sun, 20 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/20/co_await.html</guid>
      <description>&lt;p&gt;表面上我是想说 c++20 的协程, 其实我是想说, asio 封装后的 asio::awaitable&amp;lt;&amp;gt; , 这个威力巨大的武器将是未来异步的基石.&lt;/p&gt;
&lt;p&gt;asio::awaitable&amp;lt;&amp;gt; 的概念, 是万物皆可 await. 万物皆可 await 的概念实际上来自 nodejs.&lt;/p&gt;
&lt;p&gt;当初, nodejs 用回调地狱带火了异步. 既然回调地狱为何又火? 因为 nodejs 万物只能异步. nodejs 没有除了异步以外的 IO.
于是 nodejs 逼迫大家在异步的道路上进行探索, 终于诞生了 Promsie/await 对. Promise 是库, await 是语言关键字.
Promise 先出, await 后出. 没有 await 的 Promise 是不完整的 Promsie , 没有 Promise 的 await 是无法使用的废物.
两个天造地设的一对, 居然并不是同时出生.&lt;/p&gt;
&lt;p&gt;Promise 的概念就是, 所有的函数, 都不直接返回数据, 而是返回 Promise , 要取得真正的返回值, 就要 await 这个 Promise.
那么, 调用返回 Promise 函数的地方, 就变成了 initiator , 而 await promsie 的地方, 就是 completion handler.
也就是, Promsie/await 的概念, 正好契合了 Proactor 的异步并发模型. 自从有了 promise/await , 原先为了避免回调地狱而
设计为 on(&amp;lsquo;data&amp;rsquo;, lisener) 的 reactor 模式的库纷纷被抛弃, 大家都要选择 Promise 版的替代品.&lt;/p&gt;</description>
    </item>
    <item>
      <title>新能源汽车充电和三相负荷平衡</title>
      <link>https://microcai.org/2022/02/14/ev-charging-and-3phase-balance.html</link>
      <pubDate>Mon, 14 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/14/ev-charging-and-3phase-balance.html</guid>
      <description>&lt;p&gt;我喜欢直流电，本质原因是直流电是恒功率的。而交流电的功率是脉动式的。&lt;/p&gt;
&lt;p&gt;后来我才发现， 三相电也是恒功率的。&lt;/p&gt;
&lt;p&gt;因为 sin(t) + sin(t + 120) + sin(t + 240) 的函数是一条直线。&lt;/p&gt;
&lt;p&gt;从功率传输的角度来说，三相电 = 直流电 》单相电。&lt;/p&gt;
&lt;p&gt;单相交流电是最差劲的一种电。为了获得稳定的功率，所有使用单相交流电的设备不得不储备一个庞大的储能装置（通常是巨大的电解电容）&lt;/p&gt;
&lt;p&gt;这个电容储存的能量必须能足够使用 10ms（半个周期）。因此功率越大的设备就需要配置越大的电容。&lt;/p&gt;
&lt;p&gt;越大的电容就会有越大的充电电流。而且还是冲击性的。因此还需要给电容配置预充电电路，大大增加成本和复杂度。&lt;/p&gt;
&lt;p&gt;发电厂并不能发单相电，如果用户使用的都是单相电，电网还要负责平衡三相的负载。&lt;/p&gt;
&lt;p&gt;但是，把全国人分成三波，一波用A相，一波用B相，一波用C相，并不能真的平衡负荷。&lt;/p&gt;
&lt;p&gt;新能源汽车的诞生，让三相负荷平衡问题更雪上加霜了。&lt;/p&gt;
&lt;p&gt;虽然平时家用时候单相电，但是 1来家庭用电功率不打，2来大家的功率也不会相差很大。&lt;/p&gt;
&lt;p&gt;但是， 电动车就不一样了，不用的时候就是 0kw， 一用就是 7kw。&lt;/p&gt;
&lt;p&gt;为什么国家规定交流慢充最大功率 7kw？ 就时候因为考虑要做三相负荷平衡。实际上电网希望慢充不要超过 3kw，但是 3kw 太慢了，被迫接受 7kw。&lt;/p&gt;
&lt;p&gt;这方面还是特斯拉富有远见。&lt;/p&gt;
&lt;p&gt;特斯拉用单相就只能 3.3kw 充电，只有用三相电才能开启真正的交流慢充11kw。&lt;/p&gt;
&lt;p&gt;国内其他车厂，为了成本考虑，不想做11kw的三相充电，就给大家打个折扣，给你6.6kw的充电器。
但是，如果 6.6kw 如果是三相的，每相只有 2.2kw。于是在没有 380v 交流电的地方，只能使用 2.2kw 功率，消费者时候绝无可能接受如此慢的充电功率的。
于是，他们就很贱的，给整成  6.6kw 的单相充电机了。&lt;/p&gt;
&lt;p&gt;这种极度私自的行为，严重的拖垮电网。&lt;/p&gt;
&lt;p&gt;而且，6.6kw 的电绝无可能通过插座引入，实际上只能安装专用的充电桩。
可以使用插座的随车充，还是只能最大 2kw。&lt;/p&gt;
&lt;p&gt;而能安装专用的充电桩的，其实都是有条件使用380v三相电的。&lt;/p&gt;
&lt;p&gt;所以，使用 6.6kw 的单相充电器，真的好处就只有支持用户去买超大功率的山寨随车充。极大的增加风险。&lt;/p&gt;
&lt;p&gt;而且相电流高达32A，极大的增加线路起火风险。&lt;/p&gt;
&lt;p&gt;所以，还是特斯拉这种做法对电网更友好。&lt;/p&gt;
&lt;p&gt;也就是，使用 11kw 的三相充电机，单相使用为 3.3kw。
实际上220v能安全使用的最大功率是空调用的插座，16A 而已，就是 3.3kw。&lt;/p&gt;</description>
    </item>
    <item>
      <title>Future 和 Promise 的区别</title>
      <link>https://microcai.org/2022/02/05/future-and-promise-comparision.html</link>
      <pubDate>Sat, 05 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/05/future-and-promise-comparision.html</guid>
      <description>&lt;p&gt;promise 和 yield 的区别是什么？&lt;/p&gt;
&lt;p&gt;其实区别大了去了&lt;/p&gt;
&lt;p&gt;yield 虽然写异步看起来像同步，爽了。&lt;/p&gt;
&lt;p&gt;但是强制了必须等待 io 的模型。&lt;/p&gt;
&lt;p&gt;yield async io, 必须 io 完成，你的协程才能进一步执行&lt;/p&gt;
&lt;p&gt;和原来同步模式的线程io是一样的。必须 io完成你的线程才能继续。&lt;/p&gt;
&lt;p&gt;promise 则不然。 promise 可以在需要等待io结果的地方再 yield，结果出来以前可以执行其他操作&lt;/p&gt;
&lt;p&gt;在线程时代，也有一个和 promise 的作用非常类似的东西，就是 future。&lt;/p&gt;
&lt;p&gt;future 从未流行过。&lt;/p&gt;
&lt;p&gt;promise 之于协程，如 std.future 之于线程。然而 future 不流行，因为同步 IO 的写法已经过时了。
现在是异步的天下。&lt;/p&gt;
&lt;p&gt;虽然看起来有点标题党，但是 future 确实就是线程版的Promise. Promise 是为了更好的在异步环境里重叠异步操作。
future则试图给同步的线程模型里赛点异步的东西。&lt;/p&gt;
&lt;p&gt;这种硬塞就好像你给五菱宏光mini ev 塞五连杆悬挂一样，人家根本就用不上。真用上的，还会买五菱宏光吗？&lt;/p&gt;</description>
    </item>
    <item>
      <title>asio::promise yyds</title>
      <link>https://microcai.org/2022/02/04/asio-promise-yyds.html</link>
      <pubDate>Fri, 04 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/04/asio-promise-yyds.html</guid>
      <description>&lt;p&gt;最近在写以太坊的巧克力浏览器（区块链浏览器）。因为区块链浏览器需要访问历史的块，因此需要节点以 archive 模式同步。&lt;/p&gt;
&lt;p&gt;遂运行了一个 geth。 然而半个月过去了，才同步了四百万高度，而且这四百万高度的最后一百万花了80%的时间。
同步速度以肉眼可见的速度下降，ETA 变的越来越长。 从一个月慢慢的增长到6个月。&lt;/p&gt;
&lt;p&gt;于是寻找更快的客户端。找到了 erigon。erigon 号称2天完成 archive 节点同步。
结果牛逼是吹大了啊。最后耗费了10天完成了同步。&lt;/p&gt;
&lt;p&gt;geth 在同步的时候， rpc 是可用的，geth 同步到哪里， eth_getBlockNumber 返回的高度就是哪里。
因此在同步的时候，我也开始同步巧克力浏览器的数据了。&lt;/p&gt;
&lt;p&gt;巧克力浏览器是通过 eth_getblockbynumber 和 eth_gettransactionreceipt 把所有的交易数据都存入自己的数据库实现的。虽然其实可以等用户浏览到那个块再通过 rpc 获取数据，但是这样轻模式就没有检索功能了。所以还是需要解析所有的交易存入自己的数据库。&lt;/p&gt;
&lt;p&gt;最终放弃 geth 二改用 erigon 的时候，巧克力浏览器才同步到一百多万的高度，就被迫停止了。&lt;/p&gt;
&lt;p&gt;因为 erigon 只有完成同步，才会更新 eth_getBlockNumber 返回的高度。他同步的方式是先下载所有的块，然后执行，让后更新state数据，然后更新 rpc 接口的数据，然后获取最新高度，然后把落下的全下载回来，然后执行，让后更新state数据，然后更新 rpc 接口的数据，然后获取最新高度，然后把落下的全下载回来，然后执行，让后更新state数据，然后更新 rpc 接口的数据，然后获取最新高度&amp;hellip;&amp;hellip; 直到最后每次批处理的块只有1个，就算同步彻底完成。
如果 eth_getBlockNumber 一直返回 0 高度，我的浏览器就没法同步了，于是只能等。&lt;/p&gt;
&lt;p&gt;问题是，他第一次的批量的时候，就试图从 0 一直批量执行到 1401万高度。结果，执行了10天才批量执行完。这一等就是十天, 等到了除夕前一天啊。执行完毕后，就再次落后十万高度了，于是进入第二次批处理。&lt;em&gt;因为我在机械盘上运行 erigon，因此 erigon 最后会永远落后几百到几千个高度，不过这个是后话，第一次批处理完成后，我的浏览器又可以开起来同步了&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;结果，我对巧克力浏览器的同步速度非常的不满了。&lt;/p&gt;
&lt;p&gt;因为，按同步速度估算，可没法10天完成巧克力浏览器的同步。大约需要20天，而且 ETA 在增加！最后可能达到了三年之久。为啥我能提前知道eta在增加呢？因为我观察到，同步空快很快，同步内部有交易的块就慢下来了。早期空块多，但是后期基本都是满块。满块的同步速度低到令人发指的超过数秒！&lt;/p&gt;
&lt;p&gt;经过研究发现，速度是慢在了 get_transactionreceipt 上。这个接口对未缓存的交易返回速度需要数百毫秒。&lt;em&gt;第二次调用其实几个毫秒就返回了.&lt;/em&gt;
而巧克力浏览器访问的都是数年前的交易，都是属于 old data。因此每次调用它都要等待几百毫秒。
如果一个块里有个一百个交易，同步速度就惊人的 slow down 了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>江和河有什么区别</title>
      <link>https://microcai.org/2021/12/28/he-and-jiang.html</link>
      <pubDate>Tue, 28 Dec 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/12/28/he-and-jiang.html</guid>
      <description>&lt;p&gt;黄河水系和长江水系之间的万千群山。这片群山在渭水南岸的百里之遥拔地而起，横空出世，形成第一道高峰绝谷，时人叫做南山，后人称为秦岭。天下水流从这道南山分开，北面的河流绝大部分流入黄河，南面的河流绝大部分流入长江。&lt;/p&gt;
&lt;p&gt;黄河最早叫河水，河就是水名，后来才称黄河。长江最早叫江水，江是水名，后来才叫长江。类似的还有淮河最早叫淮水，淮是水名，后来才叫淮河。&lt;/p&gt;
&lt;p&gt;水最后又演变成了河江。原来的 X水 的称呼就变成了 X江 X河。
那河水自然就改名成黄河。江水改名成长江。&lt;/p&gt;
&lt;p&gt;那么水为啥演变成河江，啥时候称河，啥时候称江呢？&lt;/p&gt;
&lt;p&gt;其实这是个语言习惯问题。&lt;/p&gt;
&lt;p&gt;长江流域的人民，习惯用江。黄河流域的人民，习惯用河。&lt;/p&gt;
&lt;p&gt;其他流域的，则主要取决于汉人向其他地方迁移的时候，是那种语言习惯的人先过去的。先过去的自然就有了命名权。&lt;/p&gt;</description>
    </item>
    <item>
      <title>压燃发动机更适合做増程器</title>
      <link>https://microcai.org/2021/12/21/Homogeneous-charge-compression-ignition-better-suited-for-REEV.html</link>
      <pubDate>Tue, 21 Dec 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/12/21/Homogeneous-charge-compression-ignition-better-suited-for-REEV.html</guid>
      <description>&lt;h1 id=&#34;压燃的缺点&#34;&gt;压燃的缺点&lt;/h1&gt;
&lt;p&gt;阻碍汽油机热效率提升的根本原因是汽油机无法实现大压缩比。压缩比过大，混合气体温度过高，汽油会在火花塞点火前被压燃。这会引起爆震。需要更高标号的汽油。L:&lt;/p&gt;
&lt;p&gt;柴油机不会爆震，是因为它吸入的是纯空气。汽油机必须吸入混合气体，是因为汽油必须与空气按14比1混合。&lt;/p&gt;
&lt;p&gt;吸入多少空气就必须注入对应的汽油。要控制油门，就必须减少吸入的空气。这样就会导致压缩比降低。因此汽油机小油门下，效率大大降低。&lt;/p&gt;
&lt;p&gt;这个特性就使得汽油机很难做到压燃。即使用高压缩比实现了压燃，小油门下压缩比又会过低导致无法压燃。&lt;/p&gt;
&lt;p&gt;马自达实现的压燃汽油发动机，为了能在各种工况下工作，其实并不总是处于压燃状态。在低负载下还是要靠火花塞引燃。搞了各种点火机制进去使得发动机复杂度大大提升，导致成本无法降低。&lt;/p&gt;
&lt;h1 id=&#34;压燃用于增程的优势&#34;&gt;压燃用于增程的优势&lt;/h1&gt;
&lt;p&gt;増程器最大的特点就是工况单一。单一工况意味着压燃发动机无需再考虑无法压燃的工况。从而彻底抛弃火花塞，由此大大降低发动机复杂度和制造成本。再配以米勒循环，实现 25:1 的压缩比都不是梦。&lt;/p&gt;
&lt;h1 id=&#34;技术总结&#34;&gt;技术总结&lt;/h1&gt;
&lt;p&gt;实现用于增程器的压燃汽油发动机，其特点应该有：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;大比例废气再循环 废气冷却后再吸回气缸，降低气缸内的氧含量 增加理论空燃比&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;超稀薄燃烧 使用超过 40:1 的空燃比 超高的空燃比下的稀薄燃烧反而能大大降低气缸温度从而降低 NOx 。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;米勒循环  使膨胀比大于压缩比，降低废气温度&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;无节气门，始终充分吸入空气，0 泵气损失&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;利用发电机调节转速，始终让发电机 100% 扭矩输出。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;电辅助废气涡轮增压 在涡轮轴外部套上线圈，通电后产生的旋转磁场和废气合力推动涡轮，或者涡轮转速过高时回收涡轮能量。维持进气压力恒定以优化燃烧室设计。&lt;em&gt;异步电机的物理特性：将旋转磁场设定为需要的涡轮转速。涡轮实际转速低于旋转磁场，就会进入电动机模式，如果涡轮转速过于旋转磁场转速，自动进入发电模式。&lt;/em&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</description>
    </item>
    <item>
      <title>增程不差，直驱没那么神</title>
      <link>https://microcai.org/2021/12/20/coupling-clutch-no-that-important.html</link>
      <pubDate>Mon, 20 Dec 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/12/20/coupling-clutch-no-that-important.html</guid>
      <description>&lt;h1 id=&#34;不要迷信发动机直驱&#34;&gt;不要迷信发动机直驱&lt;/h1&gt;
&lt;p&gt;很多人以为 理想one高速油耗高，唐dmi低，是因为dmi有高速直驱模式。&lt;/p&gt;
&lt;p&gt;其实这个是不对的。发电再驱动，固然有一个能量转换效率，然而变速箱的能量传递也并非 100%。通过变速箱驱动和通过发电机电动机的间接驱动，能量传递的效率差距在10%以内。换言之，如果理想one高速是 10L 的油耗，增加直驱也不会让油耗低于9L。显然唐dmi的油耗低于9L 并不全是直驱的功劳。&lt;/p&gt;
&lt;h1 id=&#34;归根结底还是发动机的热效率&#34;&gt;归根结底还是发动机的热效率&lt;/h1&gt;
&lt;p&gt;要说唐dmi的油耗为啥比理想one低，归根结底还是因为骁云发动机的热效率远高于东安动力。使用同样的动力结构的赛力斯油耗就比理想one低，而且赛力斯比理想one还重了50kg。主要也是因为赛力斯的发动机虽然不如骁云发动机，但是也比东安动力的强不少。&lt;/p&gt;
&lt;h1 id=&#34;那直驱还是能提高一点效率的吧&#34;&gt;那直驱还是能提高一点效率的吧？&lt;/h1&gt;
&lt;p&gt;是也不是。&lt;/p&gt;
&lt;p&gt;目前来看是的，但是未来三电技术的发展，发电后驱动电机，整条能量流路径上的效率可以进一步优化。最后使得直驱带来的效率优势抵不过导致的nvh劣势而变得鸡肋。&lt;/p&gt;
&lt;p&gt;而且直驱意味着只能前驱。如果要做四驱，后轮无论如何也不能直驱。没有人会同意为了后轮直驱而给电动车加传动轴。这样四驱下，前轮直驱的效率优势就更低了。&lt;/p&gt;
&lt;h1 id=&#34;直驱咋就有nvh劣势了呢&#34;&gt;直驱咋就有nvh劣势了呢？&lt;/h1&gt;
&lt;p&gt;主要是因为，发动机要驱动车辆，就无法同车身进行柔性连接。发动机的输出轴输出扭矩的时候，机身还会有反扭矩，机身通过比较强的衬套连接在车架上来克服这个反扭矩。于是发动机的振动就不可避免的要通过连接点向车身传递。变速箱也会因为同样的原理必须固定在车身，导致振动传递。&lt;/p&gt;
&lt;p&gt;如果发动机不直接驱动车辆，而是发电，那发动机和发电机这个整体，就可以使用非常柔性的方式固定在车上。比如类似光驱里的转盘机构和光驱外壳的减震结构。&lt;/p&gt;
&lt;p&gt;这样能大大减少发动机的振动传递给车身。&lt;/p&gt;
&lt;p&gt;因此增程结构，有天然的 nvh 优势。&lt;/p&gt;</description>
    </item>
    <item>
      <title>增程式电车真香</title>
      <link>https://microcai.org/2021/11/12/bought-new-car.html</link>
      <pubDate>Fri, 12 Nov 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/11/12/bought-new-car.html</guid>
      <description>&lt;h1 id=&#34;唐dm不香了&#34;&gt;唐DM不香了&lt;/h1&gt;
&lt;p&gt;开了三年多的唐DM，总觉得比亚迪的车啊，差点意思。&lt;/p&gt;
&lt;p&gt;第一个差点的意思是，有电一条龙，没电一条虫。
虽然买的时候就知道了，但是那时候，没电的混动车，都是一条虫。&lt;/p&gt;
&lt;p&gt;但是当没电不是一条虫的增程式电动车出来的时候，唐DM就不香了。&lt;/p&gt;
&lt;p&gt;而没电一条虫的根本原因，是比亚迪糟糕的混动逻辑，导致电量无法保持。&lt;/p&gt;
&lt;p&gt;发动机低速下不启动。起步全用电。而2.4吨的家伙，要加速到40码，消耗的电能巨大。起步肉眼可见的掉电。
好不容易起来了，马上红灯就得减速。发动机刚刚起来就立马停掉。低于60的速度，如果不踩油门，发动机就会关闭。&lt;/p&gt;
&lt;p&gt;这样的混动逻辑，电怎么保的住？&lt;/p&gt;
&lt;p&gt;第二个差点的意思啊，是比亚迪背刺老车主。&lt;/p&gt;
&lt;p&gt;秒天秒地秒空气的 DMi 出来了。唐DM瞬间变成了垃圾！&lt;/p&gt;
&lt;p&gt;新车太香，于是老款贬值速度变得太快。&lt;/p&gt;
&lt;p&gt;为了不至于老款变得分文不值，决定乘现在还有点残值，赶紧出手。&lt;/p&gt;
&lt;h1 id=&#34;增程香&#34;&gt;增程香&lt;/h1&gt;
&lt;p&gt;早在2019年理想one出来的时候，我就看上了增程式。无奈那时候唐才开了一年。总不能一年就换车吧。&lt;/p&gt;
&lt;p&gt;于是安慰自己，第一代产品有缺陷的，等第二代吧。&lt;/p&gt;
&lt;p&gt;时间一晃到了2021年。这一年，汽车市场发生了翻天覆地的变化。&lt;/p&gt;
&lt;p&gt;理想出了新款，比亚迪出了DMi。华为开始造车了。&lt;/p&gt;
&lt;p&gt;新车必须式增程式的，因此我把目标锁定在了这几个车上。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;宋Plus DMI
DMI就是增程式电动车，虽然厂家从不宣传这点。但是从它的运行逻辑来看，它就是增程式电动车。
但是，宋也有致命缺陷：没四驱，筷子悬挂。于是一直等四驱DMI。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;赛力斯SF5
其实本来这个车很好，无奈有几个缺点让我一直犹豫不决。最大的缺点就是没有遥控驾驶。然后那柳叶眉的后窗不好看也不实用。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;岚图Free
和理想one差不多的价格，多提供了很多东西。属于是高性价比的理想one。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;天际ME5
假药停的遗腹子。虽然价格和宋差不多，不过比宋还是多了很多东西的。起码底盘比宋强。不是筷子悬挂。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;备选车里，没有唐DMI也没有理想one。为啥呢？因为我发现自己其实不需要那么大的车。既然宋dmi和唐dmi唯一的区别就是尺寸，那为啥要多花钱买大壳子？理想one和岚图价格一样，为啥买配置低点的理想one？&lt;/p&gt;
&lt;p&gt;这4款车决定了，于是就跑去试驾去了。&lt;/p&gt;
&lt;p&gt;试驾后发现的体会：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;岚图Free
提供了上门试驾服务，服务不错。开过来的试驾车电量只有20%了。正好可以感受下增程器开启的模式。然而上车就发现了问题。这个车因为电量低，于是增程器一直保持在开启状态。不然空调会耗尽电池。然而，试驾前销售要讲解，停车十几分钟，电量丝毫没有增加。这增程器增程了个寂寞。完全没有充电！只是单纯的怠速带空调而已。这是油车逻辑啊。一看表显油耗都到15L百公里了。于是被Pass。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;天际ME5
驾驶起来很舒服。提供了动能回收关闭的选项。关闭后，释放油门进入空单滑行非常舒适，踩刹车依然有动能回收。底盘很结实，不是筷子悬挂。开起来动力也非常猛。增程器四缸，很安静。增程器开启的时候，也是直接进入经济区间发电。不会像理想one那样为了弥补三缸缺陷，除非电量严重过低，否则增程器只运转在非经济区间低转速发电。增程逻辑是正常的。油耗也很低。可惜，只有后驱，没有四驱。销售懂都不懂，说四驱多一个电机油耗就翻倍了。pass。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;赛力斯sf5
其实这个车是第一个去试驾的，但是因为最终买了这个车，所以最后说。这个车也是上门试驾。车送到门口。这车的机械素质真的是没话说！底盘开起来非常高档，像极了 A6L。考虑到电车的无顿挫加速，那真的是 CVT + V8 版的 A6L 了。
但是，没比亚迪的遥控功能。没了比亚迪好用的安卓车机，没了比亚迪好看的外观。。。。。。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;于是就一直等宋Plus 四驱DMI。等到了9月30号。&lt;/p&gt;
&lt;p&gt;终于四驱DMI有消息了。报价20万。。。。。&lt;/p&gt;
&lt;p&gt;比亚迪飘了啊，区区紧凑型suv就敢卖20万了，而且还是麦弗逊+三连杆的悬挂。
于是直接下定赛力斯。连试驾都不去了，因为我开了3年的唐，太清楚比亚迪的底盘素质了。&lt;/p&gt;
&lt;h1 id=&#34;半月使用体会&#34;&gt;半月使用体会&lt;/h1&gt;
&lt;p&gt;半个月开了一千多公里，只在提车的时候加了200的油。一直纯电，没怎么烧油。能快充是真的舒服！
以前开唐出门的时候，都得规划下，是马上会回家呢，还是会在外面跑一阵。如果是马上回家，算下总里程会不会超过60km。
只有出门很快会回来，总里程不超过60km的，我才敢纯电出门。否则就得一路混动过去。&lt;/p&gt;
&lt;p&gt;因为唐的发电逻辑很糟糕，混动是几乎不会回充电量。除非一路匀速开高架。而低电量下混动体验非常差。所以必须得保持高电量下的混动行驶。也就是充满电后使用HEV模式行驶。这样起步用电，巡航用油。掉电多少取决于起步/急加速了多少次，和行驶里程无关。&lt;/p&gt;
&lt;p&gt;长途行驶下来，基本上到家还会有30%-50%的电量。&lt;/p&gt;
&lt;p&gt;但是，也有马失前蹄的时候，在路途中电量就到20%以下。那就非常的焦虑了。因为低电量下，起步就不能只用电了。那糟糕的双离合，起步起来顿挫的一塌糊涂。而且还没动力！因为没电了。发动机干吼车就是不走。虽然这个起步仍然比大多数日本车更快，但是，我是开惯了4.5s的人。&lt;/p&gt;
&lt;p&gt;以上是唐给我带来的糟糕馈电体验。&lt;/p&gt;
&lt;p&gt;以下是赛力斯的馈电体验。&lt;/p&gt;
&lt;p&gt;虽然基本纯电行驶。但是也抽空开了一个小长途。来回两百多公里。这个里程纯电续航就无法覆盖了。也不做特殊设置。直接走。
开了几十公里后，电量见底，进入30%。然后一个不小心，再瞄过仪表盘的时候，发现发动机早就不知不觉中开起来了。居然我毫无察觉。&lt;/p&gt;
&lt;p&gt;然后继续行驶的过程中我就时不时的看下发动机状态指示，还有剩余电量。&lt;/p&gt;
&lt;p&gt;发现，发动机并不全程开启。低速行驶时发动机不启动。只有进入30以上的车速发动机才启动。这样风噪和胎噪就盖过了发动机的噪音，难怪无法察觉。即使车速一直高于30，发动机也会停止，因为电量达到了32%。&lt;/p&gt;
&lt;p&gt;也就是说，车速高于30码的时间本身占我总行驶时间也只有一半，这一半里又有一半的时间，因为电量充足发动机就关了。发动机只有一半的一半的时间在工作，就保障了电量供应。而且全程电量没有低于29%过。保电能力不知道比唐DM高到哪里去了。&lt;/p&gt;
&lt;p&gt;发动机工作的时候非常难以察觉。因为是增程式的，发动机不驱动车辆，完全无法察觉出来发动机启动后的介入。因为根本没介入。
不像唐，发动机启动后，能察觉到离合器的闭合导致的一点冲击。而且发动机介入后，就变成了双离合的车了，能察觉到升档和降档的顿挫，还有发动机声音的变化。&lt;/p&gt;
&lt;p&gt;而增程模式下，发动机恒定转速，我使劲踩油门，发动机的声音岿然不动。并不会进入歇斯底里的状态。还是我行我素的以固定的功率发电。不足部分由电池补充。这也是这个增程系统的名字“驼峰增程器” 的由来。驾驶员对功率的需求就像骆驼的驼峰。但是增程器利用大电池，把驼峰给削了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>pipewire 不行</title>
      <link>https://microcai.org/2021/09/15/pipewire-sucks.html</link>
      <pubDate>Wed, 15 Sep 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/09/15/pipewire-sucks.html</guid>
      <description>&lt;h1 id=&#34;一切都是为了混音&#34;&gt;一切都是为了混音&lt;/h1&gt;
&lt;p&gt;声音服务器， pulseaudio, pipewire, Windows Audio, AudioFlinger, oss4, jack, esd 等等，最主要的目的，就是混音。&lt;/p&gt;
&lt;p&gt;对于消费级声卡，基本上不支持硬件混音。也就是同一时间只能让一个程序发声。&lt;/p&gt;
&lt;p&gt;至于实际上你能听到多个程序发的声音，还能单独调节各个应用的声音大小，那都是因为用了声音服务器。声音服务器就一个嘛，就解决了同一时间只能让一个程序发声的问题。其他程序想发声，把数据交给声音服务器就好了。&lt;/p&gt;
&lt;h1 id=&#34;但是大部分时候用户只想听一个程序发声&#34;&gt;但是大部分时候，用户只想听一个程序发声&lt;/h1&gt;
&lt;p&gt;其实，多个程序发声这个不是真正的需求，因为声音多了，就混乱了。用户大部分时候，只想听一个程序发声音。这个程序可以是电子游戏，可以是播放器，可以看 bilibili。
系统要只是混音，其实主要是为了处理一些 ”后台声音“ 。 比如 QQ 有消息的时候那 ”滴滴滴滴滴” 的提示。迅雷下完东西后那清脆的一声 叮。&lt;/p&gt;
&lt;h1 id=&#34;采样率混战&#34;&gt;采样率混战&lt;/h1&gt;
&lt;p&gt;声音系统，打出生以来，就没有一个全球普世的采样率标准。谁都可以自己决定采样率。
于是系统的来源声音，采样率是多种多样的。&lt;/p&gt;
&lt;p&gt;但是，最终，只能有一个采样率，因为消费级声卡只能接受一个声音流。&lt;/p&gt;
&lt;p&gt;所以声音服务器，要把各种采样率的声音都重新采样为声卡能接受的采样率，然后混音成一条音频流再输出。&lt;/p&gt;
&lt;p&gt;但是，对现有的声音产品来说，最常见的来源是 MP3 和 MP4。前者是音乐，后者是（在线）视频。纯音乐的声音，通常是 44.1khz 采样率。而视频，尤其是 H26{4,5} 为代表的新视频，通常带的是 48khz 采样率的声音。&lt;/p&gt;
&lt;p&gt;所以，消费级声卡为了照顾用户，通常会在硬件上提供 44.1khz 和 48khz 两套 （ 22.05khz 和 96khz 192khz 都是衍生采样率，所以是两套）采样率的支持。&lt;/p&gt;
&lt;p&gt;播放 mp3 的时候，就让声卡的 DAC 进入 44.1khz 模式， 播放 mp4 的时候，就让声卡进入 48khz 的模式。&lt;/p&gt;
&lt;p&gt;这样就可以避免重采样。&lt;/p&gt;
&lt;h1 id=&#34;避免重采样&#34;&gt;避免重采样&lt;/h1&gt;
&lt;p&gt;声卡都搞了2个晶振，就是为了软件不要重采样。结果，某些声音服务器啊，为了自己代码写起来方便，对应用交给他的声音，不管不顾的总是给重采样了。
过去 44.1khz 是主流的时候，他们就牺牲 48khz，后来 48khz 成了主流，他们就牺牲 44.1khz。&lt;/p&gt;</description>
    </item>
    <item>
      <title>统一</title>
      <link>https://microcai.org/2021/08/13/what-can-we-do-to-liberty-tw.html</link>
      <pubDate>Fri, 13 Aug 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/08/13/what-can-we-do-to-liberty-tw.html</guid>
      <description>&lt;h2 id=&#34;我们分裂太久了&#34;&gt;我们分裂太久了&lt;/h2&gt;
&lt;p&gt;论天下大势，合久必分，分久必合。&lt;/p&gt;
&lt;p&gt;最近一次，中国维持在统一的状态，是在一百多年前。&lt;/p&gt;
&lt;p&gt;自鸦片战争后，朝鲜分裂了，越南分裂了，吕宋岛分裂了，琉球没了。
藩国都跑了。&lt;/p&gt;
&lt;p&gt;宣统退位后，连中央国内部都开始分裂了。又开始了地方割据势力逐鹿中原的时代。&lt;/p&gt;
&lt;p&gt;逐鹿中原的过程，被日本的入侵中止过8年，日本投降后，又继续了。
最后，西元1949年，天下大定。再经过几年的时间扫荡剩余割据势力，按历史周期律，又该重新回到大一统。重新收拢藩国拱卫中央。&lt;/p&gt;
&lt;p&gt;然而，1952年，朝鲜战争打乱了统一进程。 使得窜逃到台湾的流寇得以休养生息。&lt;/p&gt;
&lt;p&gt;这一拖，就是70余年。
一百多年了，中央国都未完成统一，藩国尽失。藩国内还发生屠我汉民的恶劣事件。&lt;/p&gt;
&lt;p&gt;汉儿学得胡儿语，却向城头骂汉人。&lt;/p&gt;
&lt;p&gt;欸。&lt;/p&gt;</description>
    </item>
    <item>
      <title>推荐一款神车</title>
      <link>https://microcai.org/2021/07/15/byd-dmi-rocks.html</link>
      <pubDate>Thu, 15 Jul 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/07/15/byd-dmi-rocks.html</guid>
      <description>&lt;div class=&#34;pre&#34;&gt;
其实我算是后知后觉了，不过还是要推荐一把，毕竟比我后知后觉的人还多着。
&lt;/div&gt;
&lt;h2 id=&#34;油车为什么费油&#34;&gt;油车为什么费油&lt;/h2&gt;
&lt;p&gt;一言以蔽之，发动机高效率（相对高效）区间太窄。发动机是靠燃气的压力推动活塞做功。喷入一定量的燃油，燃烧后产生的气体膨胀速度是有限的，如果活塞下行的速度太快，燃气是来不及推活塞的。而来不及推活塞的废气最后也只能奔着打开的排气阀而去，白白把热能浪费。一定要让燃气使劲的顶着活塞走，非要走到燃气压力低到顶不动了才排气，才能最大化的利用燃气里的热能。
这就要求 1. 活塞下行的速度要和燃气膨胀速度匹配，即不能太快也不能太慢。2. 活塞必须是被燃气强行顶下，而不是自己有个自主的劲在跑. 要达到这2点，就要求：1. 发动机转速一定要维持在一个比较狭小的范围。2. 发动机的负载必须大，要把扭矩充分利用。&lt;/p&gt;
&lt;p&gt;因为扭矩负荷小，转速就得高了才能维持相同的功率，但是燃气即使遇到更低阻力的活塞，也不能膨胀的更快以维持做功不变。于做功会减少，废气会带走更多的能量。&lt;/p&gt;
&lt;p&gt;也就是说，即使转速维持在经济转速上，负荷不够，发动机也无法维持高效率。&lt;/p&gt;
&lt;p&gt;发动机只能维持一个固定的转速，和一个固定的扭矩，才能保持住高效率。离了那个范围效率就会大大降低。&lt;/p&gt;
&lt;p&gt;这个固定的范围，通常是在 2000转上下，扭矩接近发动机最大扭矩。理论上来说，应该就是最大扭矩。但是实际的发动机为了纸面数据的好看，最大扭矩下是通过过量喷油，降低空燃比实现的，所以反而效率低了。理论上最大效率下的扭矩应该是维持最佳空燃比的那个最大扭矩，通常比纸面数据低 10%。&lt;/p&gt;
&lt;p&gt;发动机最大功率通常非常接近最大扭矩 * 最大转速。所以你看一个标称  135kw 的发动机，应该是 6000转的时候以最大扭矩输出。
那么，他最大效率下的功率推测就是  135 * ( 2000/6000) * (1 - 0.1) 大约为 40kw。&lt;/p&gt;
&lt;p&gt;40kw 差不多就是搭载这种发动机的车型在高速上巡航所需的速度。&lt;/p&gt;
&lt;p&gt;这就是油车高速省油的原因。&lt;/p&gt;
&lt;p&gt;但是，在城市里开，就不是这么回事了。首先城市里开速度低，低速下的巡航功率，只有高速需求的 1/4。
所以，低速巡航效率低。&lt;/p&gt;
&lt;p&gt;然后起步，虽然低速巡航需要的功率可能只要 10kw，但是起步的时候，所需功率远大于 100kw。而这时候发动机转速却没有起来，因此是在极不经济的转速上以最大扭矩进行输出。上文说到，最大扭矩通常是以多喷燃油实现的。氧气都不够烧。尾气里含有大量未燃烧充分的燃料（冒黑烟），油耗甚至远高于以更舒适的扭矩下更高的转速进行输出（所以拖档更费油）&lt;/p&gt;
&lt;p&gt;如果变速箱齿比没适配好，还会出现明明是高效功率 40kw 的输出，却因为齿比问题导致发动机不得不以 3500转的速度+更低的扭矩实现低转高扭下相同的功率，也会导致效率低下。&lt;/p&gt;
&lt;p&gt;这也解释了为啥有的车明明发动机效率很高，他实际开起来就是更费油。&lt;/p&gt;
&lt;p&gt;所以，在城市路况下，起步，巡航，都在非经济区间运行。那油耗能低了才见鬼了。&lt;/p&gt;
&lt;h2 id=&#34;电车高速为什么费电&#34;&gt;电车高速为什么费电&lt;/h2&gt;
&lt;p&gt;因为速度越高，风阻越大。移动同样的距离，需要克服阻力做的功越多。而电机基本上什么转速下效率都挺高。于是基本上电车就是越快越费电。越慢越省电。&lt;/p&gt;
&lt;p&gt;至于为啥慢到一定地步了也会费电，那是因为车子即使不动，也会耗电。这部分静态耗电和车速无关，和你车子发动的时间有关。这方面最大的静态损耗就是空调。所以冬天哪怕电池做好温控了续航还是拉跨。&lt;/p&gt;
&lt;h2 id=&#34;混动车为啥省油&#34;&gt;混动车为啥省油&lt;/h2&gt;
&lt;p&gt;混动车，尽量维持发动机在高效范围工作。在需要发动机更大出力的时候，不是靠多喷油解决，而是靠电机辅助扭矩。
在不需要发动机大力气出力的时候，靠发电机强加一定的扭矩负荷，这部分储存的能量，就可以在需要电机辅助的时候释放出来。&lt;/p&gt;
&lt;p&gt;所以混动车省油的关键，就是要有一个巨大的蓄水池。蓄水池越大，能进行错峰调配的能量就越多。&lt;/p&gt;
&lt;p&gt;但是蓄水池大了，他贵啊！要是省的油钱没电池多，就极其不划算了。&lt;/p&gt;
&lt;h2 id=&#34;增程好就是高速更费油&#34;&gt;增程好，就是高速更费油&lt;/h2&gt;
&lt;p&gt;一辆普通轿车，如果是电车，大概率是百公里综合能耗 14度电上下。城市路况（低速但没有频繁刹车）下更可以低到 10度。
但是跑到高速上 120码乃至 130码巡航一百公里，需要的能量就会超过18度电。&lt;/p&gt;
&lt;p&gt;这都是风阻导致的。&lt;/p&gt;
&lt;p&gt;如果是增程车，意味着城市工况下，以 1L油发3度电的效率，能做到百公里电耗3.3L。但是在高速上，就可能超过 6L了。&lt;/p&gt;
&lt;p&gt;可是这种普通轿车，油车在高速上通常仅仅是5L出头的油耗。&lt;/p&gt;
&lt;p&gt;所以增程车在高速上的油耗会超过油车。&lt;/p&gt;
&lt;p&gt;这个原因就是，高速巡航正好进入油车的经济模式。但是增持车有发电再驱动的能量转换，大约会损失 10% 的能量，于是就要多烧 10% 的油。。。 5.5L * 1.1 = 6.05L。&lt;/p&gt;</description>
    </item>
    <item>
      <title>如何造发动机</title>
      <link>https://microcai.org/2021/06/17/to-build-engines-part1.html</link>
      <pubDate>Thu, 17 Jun 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/06/17/to-build-engines-part1.html</guid>
      <description>&lt;p&gt;== 热机品种&lt;/p&gt;
&lt;p&gt;最近突然对造发动机起了兴趣，遂研究研究如何造发动机。&lt;/p&gt;
&lt;p&gt;发动机，就是热机，把热能转换成机械能的机器是也。
把热能转换成机械能，谁的热能？气体的热能。&lt;/p&gt;
&lt;p&gt;因为，要在大气层里工作，工质必须得是气体才行。&lt;/p&gt;
&lt;p&gt;提取气体里的能量，有史以来也就只找到了2种方法：活塞和涡轮。&lt;/p&gt;
&lt;p&gt;所以，所有的热机，不外乎往复活塞式，或是涡轮式。&lt;/p&gt;
&lt;p&gt;而工作的气体，如果是直接燃料燃烧后的废气，就是内燃机。如果是通过热交换（俗称烧开水）获得的，就是外燃机了，&lt;/p&gt;
&lt;p&gt;四个象限下的典型热机&lt;/p&gt;
&lt;p&gt;| &amp;mdash;&amp;mdash;: | :&amp;mdash;&amp;mdash;: | :&amp;mdash;&amp;mdash;: |
|  | 内燃 | 外燃 |
| 往复活塞式 | 汽油发动机 | 瓦特蒸汽机 |
| 涡轮式 | 涡轮发动机 | 蒸汽轮机 |&lt;/p&gt;
&lt;p&gt;往复活塞式外燃机，也就是瓦特发明的蒸汽机，已经被淘汰了。
但是烧开的水推动涡轮，一时半会儿还没被淘汰。
外燃机一般使用固体燃料 &amp;mdash;&amp;mdash; 煤，如果有液态或者气态的燃料，最好的选择还是内燃机。&lt;/p&gt;
&lt;p&gt;内燃机没有体积庞大的换热装置（把废气的能量先转移给水），能减小体积，提高功率密度。&lt;/p&gt;
&lt;p&gt;所以，发动机还是内燃的好。&lt;/p&gt;
&lt;p&gt;那今天先研究研究往复活塞式内燃机。&lt;/p&gt;
&lt;p&gt;== 内燃机循环&lt;/p&gt;
&lt;p&gt;说到内燃机，就必须得有内燃机必备的4个循环：吸气，压缩，膨胀，排气
哪怕是涡轮式的也得有这4个循环。&lt;/p&gt;
&lt;p&gt;为啥非得有这4个循环呢？其实吸气，膨胀，排气都好理解，为啥非得压缩一下呢？&lt;/p&gt;
&lt;p&gt;这就不得不说到热机定律了：&lt;em&gt;理想热机的效率 = 1 - 排气温度/燃气温度。&lt;/em&gt; 理想热机的定义是，理想热机把能用来转换为机械能的内能全部转换为了机械能，剩下的就只有无法转换的废热，绝无可能再从废热里榨取一丁点的能量了。&lt;/p&gt;
&lt;p&gt;为了提高效率，就必须得降低排气温度，提高燃气温度。&lt;/p&gt;
&lt;p&gt;而排气温度受限于热力学第二定律的制约，必须高于环境温度。实际工程实践的时候，都远高于环境温度。连接近都做不到。&lt;/p&gt;
&lt;p&gt;燃料的热值是一定的，意味着燃烧前后的温差是一定的，于是理想热机的效率可以修正为&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;*1 - 排气温度/（燃烧前温度+燃料热值带来的温升）*
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;提高燃气温度，除了使用热值更高的燃料（只有造导弹的人才能自由的换燃料类型，汽油发动机已经定死了，就是汽油，没得换），还有一个办法就是提高燃烧前的温度。&lt;/p&gt;
&lt;p&gt;如果不进行压缩，燃烧前的气体温度，最多也就气温。&lt;/p&gt;
&lt;p&gt;所以压缩就是必须的，这个是提高热机效率的必经之路。&lt;/p&gt;
&lt;p&gt;== 4个冲程&lt;/p&gt;
&lt;p&gt;既然有了4个循环，又设定为是活塞式的内燃机，那内燃机的结构就呼之欲出了。就是一个活塞连在一个偏心轮上。
活塞往复运动完成4个循环，2圈旋转。每2圈完成一个工作流程。&lt;/p&gt;
&lt;p&gt;== 提高效率&lt;/p&gt;</description>
    </item>
    <item>
      <title>日本想收快递</title>
      <link>https://microcai.org/2021/04/26/zone-11-need-df.html</link>
      <pubDate>Mon, 26 Apr 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/04/26/zone-11-need-df.html</guid>
      <description>&lt;p&gt;本子跳的很欢快。日本这样的一个民族，倭人，禽兽也，畏威而不怀德。&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/hepin-riben.png&#34; /&gt;
&lt;p&gt;一枚东风携带的核弹头就足够摧毁整个日本了。&lt;/p&gt;
&lt;p&gt;驻日美军是现实的威胁，所以对东风的威胁就可以视而不见。
但是，驻日美军只威胁首相一人。&lt;/p&gt;
&lt;p&gt;宁叫全日本陪葬，毋使我首相下台 乃日本世袭政客的内心写照。&lt;/p&gt;
&lt;p&gt;届时，东风来临，首相可以乘专机逃离。被消灭的，仅仅是被愚弄后，誓死保卫首相的荣华富贵的普通平民而已。&lt;/p&gt;
&lt;p&gt;不过，没了日本人民，政客也失去了利用价值。下场不过是《星球大战》里的分离势力。派一个徒弟过去就尽数消灭了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>萌王观后感</title>
      <link>https://microcai.org/2021/04/18/limuru-the-ani.html</link>
      <pubDate>Sun, 18 Apr 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/04/18/limuru-the-ani.html</guid>
      <description>&lt;p&gt;萌王第二季前半部分完结撒花。&lt;/p&gt;
&lt;p&gt;片子，是个好片。萌王一心一意求发展。只为过上好日子。从没有想过要当什么世界霸主。&lt;/p&gt;
&lt;p&gt;萌王对敌人也很仁慈，哪怕战败，也好心接纳他们。把朋友变的多多的，敌人变的少少的。&lt;/p&gt;
&lt;p&gt;奈何你不想当霸主，霸主也视你为威胁。更关键的是，萌王的国家发展，动了西方某大国的奶酪。竞争不过对手，就使出下三滥的手段。&lt;/p&gt;
&lt;p&gt;经历过一番天真导致的惨痛教训后，萌王终于放弃幻想，准备斗争。&lt;/p&gt;
&lt;p&gt;两万马前卒，就是萌王前进路上的祭品。&lt;/p&gt;
&lt;p&gt;这哪里是写的异世界番。。。。。&lt;/p&gt;
&lt;p&gt;所以，伏濑你这是在预言本子的结局嘛？&lt;/p&gt;</description>
    </item>
    <item>
      <title>三饷已开征</title>
      <link>https://microcai.org/2021/04/10/san-xiang.html</link>
      <pubDate>Sat, 10 Apr 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/04/10/san-xiang.html</guid>
      <description>&lt;p&gt;苏联解体后，大明进入了全盛时期。 &lt;img src=&#34;https://microcai.org/images/ming-txwd.jpg&#34;  class=&#34;inline-img&#34; style=&#34;height: 12em; display:inline-flex; width: auto; &#34;&gt;
同时，大明也开始进入了衰退期。&lt;/p&gt;
&lt;p&gt;大明的衰退，首先开始于东林党&lt;img src=&#34;https://microcai.org/images/donglin-dang.png&#34; class=&#34;inline-img&#34; style=&#34;height: 3em; display:inline-flex; width: auto;&#34;&gt;和阉党&lt;img src=&#34;https://microcai.org/images/yang-dang.png&#34; class=&#34;inline-img&#34; style=&#34;height: 3em; display:inline-flex; width: auto;&#34;&gt;的斗争。&lt;/p&gt;
&lt;p&gt;当然，最终阉党是斗不过东林党的。东林势力做大后，国内土地兼并愈演愈烈。
但是，瘟疫该来的还是要来。&lt;/p&gt;
&lt;p&gt;对大明来说，消灭瘟疫最有效的手段不是防治，而是天气、屠杀和烈火。坐等百姓的生命被瘟疫蚕食。&lt;/p&gt;
&lt;p&gt;搞的天下人心尽失后，曾经被犁庭扫闾还没消灭干净的后金就开始崛起，不断挑战天朝的权威。对不听话的蛮夷，就得开除朝贡体系&lt;img src=&#34;https://microcai.org/images/chaogongtixi.png&#34; class=&#34;inline-img&#34; style=&#34;height: 3em; display:inline-flex; width: auto;&#34;&gt;&lt;/p&gt;
&lt;p&gt;开除了还活的好好的？那就得给点颜色了。&lt;/p&gt;
&lt;p&gt;可是经过前几任的折腾，国库空虚，发不出饷了。&lt;/p&gt;
&lt;p&gt;那大明就必须得开征辽饷&lt;img src=&#34;https://microcai.org/images/liao-xiang.jpeg&#34; class=&#34;inline-img&#34; style=&#34;height: 3em; display:inline-flex; width: auto;&#34;&gt;
了。&lt;/p&gt;
&lt;p&gt;再耐心点，就可以等到闯王了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>为cpu废热导风</title>
      <link>https://microcai.org/2021/04/02/redirect-airflow-in-chassis.html</link>
      <pubDate>Fri, 02 Apr 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/04/02/redirect-airflow-in-chassis.html</guid>
      <description>&lt;p&gt;两年前，我组装第一台 NAS 的时候，对 NAS 的要求就是低功耗。倒不是因为我没钱，花不起电费。而是低功耗 = 低散热需求 = 低噪音。&lt;/p&gt;
&lt;p&gt;毕竟，NAS 是放家里运行的。如果像商品服务器那样，开机约等于飞机起飞，是没法放家里的。
但是功耗大了，就一定有噪音吗？&lt;/p&gt;
&lt;p&gt;最近为公司升级服务器的时候，把3700X 淘汰下来换成了 7302P。EPYC 使用了 4U 高度的散热器后，声音并不大。和普通PC并无区别。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;大部分情况下，使用 PC 平台足够承担服务器的工作。而且成本低非常多。唯一需要注意的是，得把 PC 平台常用的内存换成工作站使用的 Unbuffered ECC 内存。不信各位看看各大云产商的主流虚拟机配置，都是比家用 PC 配置略低的 *&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;实际上，我们也本不需要升级 epyc，只要再配置一台 PC 也足矣。但是因为我们排斥云，坚持使用物理机。排斥机房，坚持将服务器放办公室运行，因此并不希望增加机器的数量增加维护成本。服务器独享一条专线，并不和办公室的网络共享，因此服务器是直连ISP，中间没有使用路由器和交换机。这样可以简化网络的配置。如果使用2台服务器完成工作，就需要增加路由器和交换机了，增加网络设备，就增加了失效点。再三考虑后，决定升级 epyc 而不是用两台 PC *&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这次为公司装服务器的经验，促使我后来将家里的 &lt;a href=&#34;https://microcai.org/2021/03/28/epyc-as-3rd-nas.html&#34;&gt;NAS 升级为 EPYC&lt;/a&gt;。原来只要管理好风扇转速，然后设计好风道，epyc 也是可以凉又静的。&lt;/p&gt;
&lt;p&gt;是的，要设计好风道！&lt;/p&gt;
&lt;p&gt;由于服务器上的发热大户就只有 CPU，没有显卡。机箱里是空荡荡的，就一个高耸的散热器塔。装完服务器后我就想，这巨大的塔，把热量都排在机箱里面，太贱了。这就导致机箱必须加装散热器，把废热排出机箱。服务器开机起飞的罪魁祸首就是机箱的暴力风扇。&lt;/p&gt;
&lt;p&gt;为什么 CPU 的废热不能直接排出机箱？非要先排到机箱里面，再利用机箱的风扇和风道排出机箱？&lt;/p&gt;
&lt;p&gt;水冷效果为什么好，不就是因为水冷不会把 cpu 的热量排入机箱么！&lt;/p&gt;
&lt;p&gt;风冷能不能学水冷？&lt;/p&gt;
&lt;p&gt;你肯定会不假思索的说不能。因为风冷的热管是硬的，没法调整散热片的位置，只能待 cpu 上方。热量就必然只能排到机箱里。&lt;/p&gt;
&lt;p&gt;如果给cpu的散热器加个套，让他的废气直通机箱外部呢？那还需要个鬼的机箱风扇！&lt;/p&gt;
&lt;p&gt;bingo！&lt;/p&gt;
&lt;p&gt;想到了这点，说干就干！立马用3D打印机打印了一个散热器罩子。完美契合散热器和机箱的排风孔。机箱的排风口上的风扇就彻底的抛弃不要了。&lt;/p&gt;
&lt;p&gt;少了一个风扇，cpu 的温度非但没有降低，还让主板其他元件再也不受 cpu 的废热之苦。
少了一个风扇，少了一个振动源，噪音大大降低&lt;/p&gt;
&lt;p&gt;但是为什么cpu散热器不自己带个罩子呢？或者机箱不提供这个罩子呢？还非得我自己造。&lt;/p&gt;</description>
    </item>
    <item>
      <title>epyc deployed</title>
      <link>https://microcai.org/2021/03/28/epyc-as-3rd-nas.html</link>
      <pubDate>Sun, 28 Mar 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/03/28/epyc-as-3rd-nas.html</guid>
      <description>&lt;p&gt;去年的 &lt;a href=&#34;https://microcai.org/2020/12/18/nas-upgraded.html&#34;&gt;这篇文章&lt;/a&gt; 里我受够了嵌入式 ATOM 处理器羸弱的性能而斥巨资购买了 锐龙 5600X 作为新的NAS机器的处理器。然而好景不长，这个新NAS才服役不到4个月，就被我&lt;a href=&#34;https://microcai.org/2021-03-07-pcie-shortage-problem.html&#34;&gt;嫌弃了&lt;/a&gt;。在&lt;a href=&#34;https://microcai.org/2021/03/07/pcie-shortage-problem.html&#34;&gt;这篇文章&lt;/a&gt; 的结尾，我提到了 &lt;em&gt;EPYC 的精髓在单路&lt;/em&gt; 这句话。
这竟是我抛弃第二台NAS的导火索。&lt;/p&gt;
&lt;p&gt;起初，我购买 NAS 只是为了做一个下载机。开个 Download Station 下下高清的片子。后来我希望它能承载更多的任务，然而 A53 + 512M 的平台，无论如何无法承载更多。于是就有了第一台NAS。原谅我甚至不把那台DS216j看成第一台NAS。&lt;/p&gt;
&lt;p&gt;最初第一台 NAS 没有远见，机器毫无扩展性。甚至初期只用4个盘。但是好歹也有了大容量。也能突破千兆的瓶颈了。
用了一阵子后，受不了 atom 的性能而进行了更新。&lt;/p&gt;
&lt;p&gt;第二台NAS性能非常棒。毕竟 zen3 架构，单核南波万。也正是因为他巨大的性能提升，导致我不只是把它当NAS了。他成了我的私人服务器。不仅仅运行 samba 共享，还运行多媒体服务，还运行 nextcloud 私人备份，当然跑 bt 下载也是少不了的。&lt;/p&gt;
&lt;p&gt;除此之外，他还对我公司的线上数据进行热备。算是一份异地灾备。
然后，还运行了多个区块链的节点 —— 什么比特币，以太坊，波场币，统统都跑一个节点看看。&lt;/p&gt;
&lt;p&gt;这下完犊子了。由于使用的是 ITX 主板，只有2条内存插槽，导致内存最大就被限制到了64G。运行了那么多服务，内存开销自然是小不了。于是时不时的就看到 OOM 崩溃日志。&lt;/p&gt;
&lt;p&gt;加了 SWAP 后算是缓解了OOM。但是 iostat 可以看到 swap 文件长期保持在 300M/s 的读取速度 —— 不用说，就是内存不够了，被大量的 drop 掉，然后又马上访问于是又得 swap in 。&lt;/p&gt;
&lt;p&gt;内存不足，是一件迫在眉睫的事情。我至少需要 128G 的内存！ 换成 matx 的主板固然可以低成本解决问题 —— 但是，128G 要还是不够用了咋办？ 这可是 PC 平台 4条 DIMM 的极限容量了。再增加容量就只能上 64G 单条了。而64G单条又必须是Registered ECC内存，Unbuffered ECC不论如何都只有32G，再大没有了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>ATX 机箱明明有7个pcie槽位</title>
      <link>https://microcai.org/2021/03/07/pcie-shortage-problem.html</link>
      <pubDate>Sun, 07 Mar 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/03/07/pcie-shortage-problem.html</guid>
      <description>&lt;p&gt;去年的 &lt;a href=&#34;https://microcai.org/2020/12/18/nas-upgraded.html&#34;&gt;这篇文章&lt;/a&gt; 里我受够了嵌入式 ATOM 处理器羸弱的性能而斥巨资购买了 锐龙 5600X 作为新的NAS机器的处理器。
通过 PCIe 拆分卡&lt;img src=&#34;https://microcai.org/images/pcie_bifurcation.jpg&#34; class=&#34;inline-img&#34; style=&#34;height: 8em; display:inline-flex; width: auto;&#34;&gt;实现了 HBA 和 10G 网卡同时接入。把主板的 pcie x16 的显卡槽给利用上了。&lt;/p&gt;
&lt;p&gt;但是，近期发现了一些好东西，就琢磨着给NAS插上。但是想到这些好东西都需要占用主板的 PCIe 槽的时候就犯难了。
锐龙处理器一共就20条可利用的 pcie 通道（还有4条接南桥，不可利用了）。16条给了显卡槽，4条给了第一个 M.2 槽。
&lt;em&gt;PS, intel 的桌面处理器算上南桥的4条也才20条pcie通道。更糟糕&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;给显卡的那条我已经用带拆分的延长器给弄成了2条 x8 的，一条接了 HBA 一条接了网卡。可是，想多接几个 pcie 设备又怎么办？&lt;/p&gt;
&lt;p&gt;&lt;em&gt;PC 平台最大的缺陷是PCIe通道数不足。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;甚至intel就靠卖pcie通道数赚钱。&lt;/p&gt;
&lt;p&gt;明明 ATX 标准设定了7个扩展槽位！而ATX显然是PC的标准，不是什么服务器的标准。&lt;/p&gt;
&lt;p&gt;虽然 ATX 标准是 PCI 时代的产物，但是 PCI 进入 PCIe 时代，主板也应该是把7条PCI槽升级为7条pcie槽。而不是就变成光秃秃的秃驴，就剩下显卡一个槽，剩下的就给 pcie x1 的打发乞丐。而且凑数的 pcie 还是南桥出的，还和 SATA/M.2 有冲突，二选一。&lt;/p&gt;
&lt;p&gt;想到这点，我突然明白了为什么有人说，&lt;em&gt;EPYC 的精髓在单路&lt;/em&gt;。&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/ROMED8-2T-2(L).jpg&#34; width=&#34;75%&#34;&gt;
&lt;p&gt;看这个主板，齐刷刷的7条pcie多漂亮！&lt;/p&gt;</description>
    </item>
    <item>
      <title>SFP&#43; 的下一代，是 SFP112</title>
      <link>https://microcai.org/2021/01/01/sfp112.html</link>
      <pubDate>Fri, 01 Jan 2021 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2021/01/01/sfp112.html</guid>
      <description>&lt;p&gt;以太网的标准，通常以10倍来翻倍。10M 100M 1G 10G 100G.
10G 的下一代，应该进化到 100G，可是中间横插入了 40G。这不伦不类的 40G 不仅仅速度不清真，更重要的是，他把以太网带入了歪路。导致了 100G 以太网接口有了3重版本。&lt;/p&gt;
&lt;p&gt;以太网迈入光纤时代，不管是 100M 还是 1G 还是 10G，都使用的一个漂亮的接口，SFP。SFP 接口包含了一对数据链。模块只做电光转换。协议处理由后端负责。&lt;/p&gt;
&lt;p&gt;简单，优雅。&lt;/p&gt;
&lt;p&gt;可是，横插入的 40G 以太网打乱了这个简单优雅。设计了 QSFP 接口。一个 QSFP 其实是4个SFP的简单叠加。重用了供电和其他功能性引脚，但是直接塞入了4对数据链。所以相比4个SFP接口，体积还是稍微小了点。&lt;/p&gt;
&lt;p&gt;但是，这个 QSFP 接口，带来了无穷的混乱。首先就是 4对数据链路导致 QSFP 模块必须插8根光纤，进而让LC SC 这种简单的耦合设计无用武之地。使是有些只有2根光纤的，拿也是在模块内部使用了波分复用，使用了4条激光发送数据。一对光纤一对路的原则被破坏殆尽。我很不喜欢 QSFP。这更导致了 QSFP 没有 bidi 模块（使用一条光纤同时收发的模块）。&lt;/p&gt;
&lt;p&gt;第二个混乱在于，QSFP 被证明用户被强奸后也默默接受了，于是 100G 以太网还要使用4对链路收发。不过谢天谢地没有使用8对链路。但是，标准委员会又引入了不兼容，搞了 QSFP28 接口。&lt;/p&gt;
&lt;p&gt;有 QSFP28 就有 SFP28 了。大小也不一样了，直接物理层不兼容。一下子整出了4个模块接口。SFP SFP28 QSFP QSFP28. 除了 SFP 能塞进 100M 到 16G 之间的各种速度（兼容性大大的好）。。。 其他的都只为以太网的一个特定速度设计。&lt;/p&gt;
&lt;p&gt;这样，10G 并不能平滑的升级，因为不管是 25G 40G 还是 100G，速度，接口都不一样。&lt;/p&gt;
&lt;p&gt;也许是觉得这个局面不够混乱，以太网又整了个50G出来。&lt;/p&gt;</description>
    </item>
    <item>
      <title>升级了NAS机器</title>
      <link>https://microcai.org/2020/12/18/nas-upgraded.html</link>
      <pubDate>Fri, 18 Dec 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/12/18/nas-upgraded.html</guid>
      <description>&lt;p&gt;上次折腾NAS, 最后搞了8个8T的盘阵列。但是，我愈发的不满意 C3558 的性能。准备替换掉它。但是又觉得C3558花费巨大，没用回本实在不甘心。&lt;/p&gt;
&lt;p&gt;最近几个月，zfs 频繁出现 checkcum error。但是诡异的是，总是 sda sdb sdc sdd 这4个盘出现。&lt;/p&gt;
&lt;p&gt;感觉主板出了问题。或者是机箱的背板出了问题。不论哪个出了问题，都到了让C3558退休的时候了。&lt;/p&gt;
&lt;p&gt;既然要退休，就要想好继任者。继任者在 MIPS （龙芯） ARM64(鲲鹏) 和 x86 里。有缺点都特别明显。&lt;/p&gt;
&lt;p&gt;龙芯&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;优点
&lt;ul&gt;
&lt;li&gt;从 bios 到 内核 到 userland 整个都是开源的。方便折腾。&lt;/li&gt;
&lt;li&gt;bios 可以通过串口访问。取消了 IPMI 的依赖依然可以不接显示器键盘进行配置&lt;/li&gt;
&lt;li&gt;低功耗
当然，缺点也很大。第一个缺点就是性价比太低。然后性能也跑不满万兆网络。说不定还不如 C3558 呢。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;鲲鹏&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;优点
&lt;ul&gt;
&lt;li&gt;arm 架构在 linux 里的支持度不亚于 x86. 比 mips 好太多。&lt;/li&gt;
&lt;li&gt;性能足够，能跑满万兆&lt;/li&gt;
&lt;li&gt;进行嵌入式开发的时候可以直接为开发板编译软件，不用在 pc 上配置交叉编译环境。&lt;/li&gt;
&lt;li&gt;bios 依然可以通过串口访问。无需依赖 IPMI&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;除了性价比太低，么有特别的缺点&lt;/p&gt;
&lt;p&gt;x86 的选择就大了，最终我在3个方案里选择。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;方案1
intel E3 神U + ECC 内存 + SAS HBA + 万兆网卡 + 4U 8盘 380mm深度机箱。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这个是翼王使用的配置。缺点是他是牙膏厂的东西。吃了C3558的亏后不想用牙膏厂的东西，而且14nm的能耗比也差。&lt;/p&gt;</description>
    </item>
    <item>
      <title>读书人最容易出卖灵魂</title>
      <link>https://microcai.org/2020/07/26/faked-freedom-speech.html</link>
      <pubDate>Sun, 26 Jul 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/07/26/faked-freedom-speech.html</guid>
      <description>&lt;p&gt;咱国家其实对明朝研究的特别少。特少。&lt;/p&gt;
&lt;p&gt;很多人说宋代是文人最好的时代。其实大错特错。 宋代的文人只能写词。明代的文人直接执掌国家。&lt;/p&gt;
&lt;p&gt;很多读书人被明朝皇帝打死，你说明朝读书人有骨气。&lt;/p&gt;
&lt;p&gt;当我真的去研究明朝的那些事的时候，才知道哪里是骨气。分明是利益。&lt;/p&gt;
&lt;p&gt;明朝的时候，税只能向农民收。如果要向商人收税，那是要被读书人批评为“与民争利”的，他们为了阻止皇帝收税，是宁可被打死的。征辽响的时候，他们不会劝皇帝与民休息。征商税的时候，朝廷大员们是要“死谏” 的。&lt;/p&gt;
&lt;p&gt;什么“与民争利”，“藏富于民”， 这里的“民” 一直都是指那些读书人。对读书人不好，还舍不得下杀手的，那一定是暴君。要向读书人收税，那一定是横征暴敛，一定是民不聊生。但是，只要能痛下杀手，读书人的膝盖又是最软的，一定跪下来称你是民心所向，是太平盛世。&lt;/p&gt;
&lt;p&gt;所以平头老百姓啊，千万不要听读书人忽悠。读书人说天下太平的时候，那可能只是说读书人有出路。读书人说民不聊生的时候，那可能只是朝廷不喜欢那些穷酸秀才。&lt;/p&gt;
&lt;p&gt;秦始皇坑几个犬儒，就是暴君了。满清皇帝嘉定三屠，还是圣君。很多时候，百姓是不能发声的。要有个好名声，做好事是没用的，只需要管好读书人的嘴就够了。因为读书人的膝盖是最软的，最容易出卖灵魂。&lt;/p&gt;
&lt;p&gt;&lt;del&gt;读书人里，又以山东的读书人膝盖最软。孔圣人跪过蒙古大汗，也跪过满清皇帝。满清灭亡后，还跟着蒋介石去了台湾。如今跟着绿营认了日本人做父亲。 留在山东的就更没骨气了，要量山东之学子，结黑爹之欢心。&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;要想读书把灵魂卖给你，就需要有天命。有了天命，读书人的膝盖就跪过来了。所谓天命，就是可以让读书人对你进行双标的光环。有了这个天命，入侵他国就不再是入侵，而是吊民伐罪。不论做什么都没事，自有天下的读书人帮你洗。&lt;/p&gt;</description>
    </item>
    <item>
      <title>国产汽车战略秒棋-tesla上海工厂</title>
      <link>https://microcai.org/2020/07/15/tesla-and-china-ev.html</link>
      <pubDate>Wed, 15 Jul 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/07/15/tesla-and-china-ev.html</guid>
      <description>&lt;p&gt;汽车这个产业也有上百年的历史了，要想在这个行业崛起，难度非常大。我们国家选择了弯道超车，就是压宝电动车。&lt;/p&gt;
&lt;p&gt;国家发展电动车，最大的困难是什么？&lt;/p&gt;
&lt;p&gt;有人说，是续航短。有人说，是充电麻烦。&lt;/p&gt;
&lt;p&gt;但是，这其实都不是最大的困难。&lt;/p&gt;
&lt;p&gt;最大的困难在人心。&lt;/p&gt;
&lt;p&gt;为什么不买电动车？充电？续航？这都不是真正的考虑。其实，让中国百姓不想买电动车的原因，就只有一个：只能选国产。 国产就是原罪。所有汇集到电动车上的槽点，无非是国产车里挑刺思维的延续。&lt;/p&gt;
&lt;p&gt;任何产品，都有优点和缺点。完美的产品是不存在的。优点能满足你的需要就买，缺点是可以忽略的。&lt;/p&gt;
&lt;p&gt;但是如果你不喜欢一个产品，那优点是看不到的，缺点是可以无限放大的。直到所有缺点都被解决，你还是会说最后一句话气死销售：“我就是不喜欢它啊！“&lt;/p&gt;
&lt;p&gt;放到汽车上，道理是一样的。当车企专注于 fix 电动车的缺点的时候，其实忽略了消费者最简单的心理：他找的缺点都是借口，他只是单纯的不喜欢你而已。&lt;/p&gt;
&lt;p&gt;这个道理，国内一大票造车的都没懂，太平洋彼岸的一个传销头子领悟到了。与其去不断的 fix 电动车的固有缺陷，不如直接无视这些人，把优点发挥出来，让喜欢的人喜欢，让讨厌的人滚蛋。&lt;/p&gt;
&lt;p&gt;这个思维，成就了 tesla。&lt;/p&gt;
&lt;p&gt;那么回到国内，为啥引入 tesla 是国家新能源汽车战略中最妙的一招棋呢？因为中国百姓，他不是不能接受充电慢，不是不能接受续航短。&lt;/p&gt;
&lt;p&gt;他唯一不能接受的是，不能买国产车。&lt;/p&gt;
&lt;p&gt;而电动汽车，是没有洋牌子的。既然没有洋牌子，那就不买。其他的都只是找的借口。&lt;/p&gt;
&lt;p&gt;不买的永远都有不买的借口。真信了你就输了。&lt;/p&gt;
&lt;p&gt;国家终于明白，要推广新能源汽车，就要先治好软骨病。而这个病，最好的解药是以毒攻毒。&lt;/p&gt;
&lt;p&gt;没有洋牌子，就先扶一个洋牌子进来。这个洋牌子，最好是不掌握电动汽车核心技术的。日后打压起来轻松。&lt;/p&gt;
&lt;p&gt;放眼过去，能造好电动车的洋牌子，就在德日美三个国家里找。德国深耕石油车百年，在电车领域已经变成了阿斗。能打的一个都没有。排除了德国，就是日本和美国。&lt;/p&gt;
&lt;p&gt;日本鬼子，虽然电动汽车看起来没啥本事，但是，日本有强大的机电产业！放日本车进来，别看小日本今天没啥电动车，可是人家三电技术哪个没有？ 电池电池造的好，电机电机造的好，电控。。。 那玩意就是功率半导体，也是小日本的强项。&lt;/p&gt;
&lt;p&gt;所以，日本车，因为后劲过于强大，绝对不可引进。不仅仅不能引进，还要极力打压！&lt;/p&gt;
&lt;p&gt;剩下的就是美国了。&lt;/p&gt;
&lt;p&gt;美国的电动车，就和他家的手机一样。只有一个能打的牌子，还特别能打。但是都有致命缺陷：只有营销手段没有核心技术。&lt;/p&gt;
&lt;p&gt;美国的电动车，电机靠台湾，电池靠日本，电控自己虽然有，但是不如小日本，也不如中国的。靠的吹牛皮不死人的营销无敌技术占领的大市场。&lt;/p&gt;
&lt;p&gt;但是，美国的汽车犹如南山必胜客，看起来很强大，但是，是压根上不了美国制裁的实体清单。&lt;/p&gt;
&lt;p&gt;但是，中国的电动车推广，需要的并不是技术，恰恰是美国佬那不要脸到极点的营销技术。用美国的营销手段，把中国的老百姓给洗脑成接受电动车，则国家战略成咦。反正美国佬的车，其实从根上来说，就不讨中国人喜欢。&lt;/p&gt;
&lt;p&gt;等美国佬完成洗脑中国百姓的目的，他就可以被抛弃了。&lt;/p&gt;
&lt;p&gt;为什么上海要求tesla的所有零件实现国产？因为电动车全产业链都在中国。tesla完全可以100%使用中国零件。&lt;/p&gt;
&lt;p&gt;而使用100% 中国零件的 tesla，完成了使命后，只需要把 logo 换成中国姓，改动如此小，百姓接受起来也就容易了。最难的，接受电动车这个，已经由洋大人完成了洗脑。剩下的，无非就是 logo 换成中国字而已。接受起来不要太轻松。&lt;/p&gt;
&lt;p&gt;李斌是第一个吃透了国家战略的人。他把 ES8 卖给了 Tesla 车主当成第二个玩具。轻轻松松就做到了那是duck上市。&lt;/p&gt;
&lt;p&gt;不管 tesla 卖的有多好，最后都是在帮国产电动车培养用户。因为 tesla 的核心技术，其实在中国人的手里。&lt;/p&gt;
&lt;p&gt;千万不能让小日本的电动汽车起来！必须要打压，严厉的打压。美国人不会造电池，他小日本会。美国人不会 cost down ，他小日本会。&lt;/p&gt;</description>
    </item>
    <item>
      <title>高压钛酸锂电池组完成</title>
      <link>https://microcai.org/2020/07/11/high-voltage-battery-done.html</link>
      <pubDate>Sat, 11 Jul 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/07/11/high-voltage-battery-done.html</guid>
      <description>&lt;p&gt;大部分交流设备，其实都有一个前置的全桥整流器，把交流输入转换为直流，然后内部再根据需要进行各种变换获得需要的电能。&lt;/p&gt;
&lt;p&gt;这意味着，其实所谓的 AC 输入，倒不如说是支持无极性直流输入。&lt;/p&gt;
&lt;p&gt;既然如此，为啥还要搞逆变器呢？直接把电池输出怼上去就完事了。&lt;/p&gt;
&lt;p&gt;问题是，上哪找220v的电池？&lt;/p&gt;
&lt;p&gt;既然没有，那就自己组一个吧。电池嘛，串起来不就有高压了。&lt;/p&gt;
&lt;p&gt;如果使用的是铅酸电池，倒是这个理。&lt;/p&gt;
&lt;p&gt;可是，铅酸电池我不喜欢啊！要用就要用锂电池，而且得是钛酸锂。一旦用了锂电池，就有问题了，需要 BMS。&lt;/p&gt;
&lt;p&gt;而 BMS 就限制了DIY的时候能串的电池的个数了。首先就是市面上最最最常见的 BMS： 达锂和蚂蚁。最多都只支持到 32节电池。&lt;/p&gt;
&lt;p&gt;32节电池只能实现。。。 2.2V*32 = 70.4v 的电压。&lt;/p&gt;
&lt;p&gt;两个保护板一起串起来呢？咨询了BMS厂商后得知并不能串联。容易烧板子。&lt;/p&gt;
&lt;p&gt;但是新能源汽车倒是串联很多电池。。可见管理几百节串联的 BMS 是有的，只是用的汽车上，DIY 市场上没出。&lt;/p&gt;
&lt;p&gt;这个事情就作罢，一直作罢了几年。直到最近突然给我找到了。&lt;/p&gt;
&lt;p&gt;淘宝上找到了一家做锂电池BMS的，支持最多96节电池串联。支持钛酸锂。他的设计是使用 控制卡 + 采集卡 的分体构造。一个采集卡可以采集 12节电池的信息。 控制卡理论上支持采集卡无限级联，实际上软件只支持到8张采集卡。 12×8 = 96。这就是96节限制的由来。采集卡和控制卡之间使用的 RS485 传递信息。因此采集卡和控制卡不共地，也就是说控制卡不受总电压限制。唯一限制总电压的地方，其实用来 关断电池 的 MOS 管的耐压。然而，他可以使用继电器代替 MOS管。&lt;/p&gt;
&lt;p&gt;&lt;em&gt;小知识： 为什么如果共地会有总电压限制呢？&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;信息通信需要电平。如果采集卡和控制卡使用普通的TTL/RS232协议通信，意味着需要共地。采集卡的 GND 是12串电池的负极，他的 TX 信号对 GND 有 5V。但是只有第一组电池的负是控制卡的 GND，第二组电池的GND是第一组电池的总电压。以 4.2v锂电池为例，第二组电池的逻辑高电平为12*4.2+5=55.4V , 逻辑低电平为12×4.2 = 50.4v ,   到第8组电池，逻辑电平就超过 200V 了。这样，通信的逻辑信号输入端就需要耐受总电池电压。这就是DIY BMS 最多只有32S 的原因。更多的电池需要更高耐压的单片机输入电平转换电路。更糟糕的是，逻辑电平的电压还会随着电池的放电进行迁移。大大增加电平判定难度。&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;到了以后发现这个pcb板子不好固定,&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/bms-look.jpg&#34; &gt;
&lt;p&gt;所以3D打印了一个卡座&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/bms-shell-3d-print.jpg&#34; &gt;
&lt;p&gt;&lt;em&gt;是的，这是第一次使用3D打印，从此爱上了3D打印。。。 后来为了可以不用等好几天，就干脆自己买了3D打印机。。。&lt;/em&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>入手了一个 rock pi 4b</title>
      <link>https://microcai.org/2020/06/13/bought-rockpi4.html</link>
      <pubDate>Sat, 13 Jun 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/06/13/bought-rockpi4.html</guid>
      <description>&lt;p&gt;闲来无事，又打起了ARM的主意。Rpi3 的性能实在受不太了。毕竟只有 100M 网络。内存也就1GB。想干点啥都不行。寻思着弄个性能好点跟的上时代的 arm 板子玩玩。&lt;/p&gt;
&lt;p&gt;先是找 archlinuxarm 看看有没有啥支持的板子。结果发现都不是啥好板子。后来搜 香蕉派的时候，发现了 rock pi。rock pi 4b 看参数，给力。于是下单了一个 4G 内存的版本。这 rock pi 最吸引我的地方是有一个 M.2 插槽，而且支持从 nvme 启动系统。终于可以丢掉渣 SD 卡了啊。&lt;/p&gt;
&lt;p&gt;于是马上下单买了一个。&lt;/p&gt;
&lt;p&gt;过了几天到了，把官网上提供的 debian 系统给 dd 到 nvme ssd。然后发现无法启动。&lt;/p&gt;
&lt;p&gt;先研究 nvme 启动吧。cpu 并不支持从nvme 直接启动。或者说 cpu 内带的 bootrom 只支持 SPI/sd/emmc 三个启动方式。那么就需要先让 bootrom 载入一个 loader，这个 loader 再从 nvme 载入系统。但是我又不想插 sd卡，于是就需要有 SPI flash。&lt;/p&gt;
&lt;p&gt;然后他这个板子是有焊接上 SPI Flash的，但是却没有烧bootlader进 Flash。&lt;/p&gt;
&lt;p&gt;所以默认还是只能 SD卡启动。于是先把他官方提供的 ubuntu img 给 dd 到 SD 卡然后启动。&lt;/p&gt;
&lt;p&gt;然后按照 wiki 把 spi 版的 uboot 给刷入板子上的 SPI flash。&lt;/p&gt;</description>
    </item>
    <item>
      <title>为家里所有设备一次更新 ipv6 动态域名</title>
      <link>https://microcai.org/2020/04/27/all-device-ipv6ed-and-ddnsed.html</link>
      <pubDate>Mon, 27 Apr 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/04/27/all-device-ipv6ed-and-ddnsed.html</guid>
      <description>&lt;p&gt;来了！ ipv6 真的来了！ 最近回一趟老家，发现老家的 ipv6 也可以用后， 家，公司，老家1，老家2 四个地方的 ipv6 就全部都能互通了。这样，就没有理由留着 ipv4 了。我甚至觉得搞个公网 ipv4 地址是多么可笑的一件事。&lt;/p&gt;
&lt;p&gt;全ipv6化以后，为了互连方便，我把所有的支持 ipv6 的设备，都配置了动态域名。编译了 dnspodc 还有交叉编译了 dnspodc 到各种设备上。但是，打印机让我头疼了。打印机支持ipv6, 但是不支持运行自己写的程序。&lt;/p&gt;
&lt;p&gt;而且为那么多设备一个一个编译并配置 ddns 更新程序，着实让我有点筋疲力竭。我开始思考，让一个程序自动为所有设备都更新 ddns。&lt;/p&gt;
&lt;p&gt;ipv6 地址，使用的是 prefix + host 的方法构成。不同于
ipv4 时代 prefix 按照 /8 /16 /24 分成了 A B C 三类地址，后来又发明了 CIDR 无分类地址，可以使用任意长度的 prefix， ipv6 时代建议 prefix 永远等于 64 。低于 64 的 prefix 只用于地址分配机构分配地址，还有路由聚合简化路由表的时候用。实际过程中进行地址分配，一个局域网下永远让 prefix=64。&lt;/p&gt;
&lt;p&gt;这么做有个什么好处呢？ 就是 无状态地址自动配置 能发挥作用。而且 64bit 的 prefix 意味着 主机地址可以有 64bit， 也就是说永远不会遇到 主机位不足的情况。 ipv4 时代使用 C 类地址的时候，就容易遇到局域网超过 255 台机器的情况。好不容易划好的网络，增加一台可能导致整个网络重新规划。而 64bit 的 prefix 一劳永逸的解决了这个问题。&lt;/p&gt;</description>
    </item>
    <item>
      <title>自由市场思维毁了区块链</title>
      <link>https://microcai.org/2020/04/20/free-market-also-failed-blockchain.html</link>
      <pubDate>Mon, 20 Apr 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/04/20/free-market-also-failed-blockchain.html</guid>
      <description>&lt;p&gt;西方的自由市场思维很有诱惑力，然而实际上根本行不通。拿 99 碗饭 100 个人来说， 这饭要如何涨价呢？ 无论涨到多少，终会有一个人买不到然后饿死。&lt;/p&gt;
&lt;p&gt;这个时候根本就不能允许自由涨价。很多人说，那是粮食有特殊性，别的物资可以随便涨价吧？
但是，谁来定义所谓的 “特殊商品” 呢？在美国肺炎出现前，也没有人会认为口罩是特殊商品，不能涨价吧。&lt;/p&gt;
&lt;p&gt;一些人可能会说，涨价大家才有动力增产。这又是在说胡话了。这个世界产业大分工下，大部分制造业者早已放弃了制造自己不擅长的东西了。每一个商品的背后，都只是寥寥数个参与的品牌。新进的人已经很难在参一脚了。何况有一些行业还设立了特殊的壁垒。涨价就有新竞争者入局增加供给，只能说理想很美好，现实很骨感。&lt;/p&gt;
&lt;p&gt;而受西方自由市场思维洗脑最深刻的中本聪，也陷入了自由市场的陷阱。他让区块链的交易费用“市场化竞争” 。看起来 “出价最高者，他的交易被打包” 这个游戏规则非常公平而天经地义。但是实际上是落入了陷阱。因为不论你出价多高，比特币的容量是无法增加的。每10分钟只能打包一个区块，每个区块只能有 1MB 字节。1MB字节只能打包大约2000-3000笔交易。这就是打包比特币交易这个商品的供应上限。 在一个有供应力上限的市场里搞自由竞价。结果就只能是所有参与者都被迫无限推高支付的手续费，直到达到“所能承受的手续费上限”，一旦突破承受极限，只能放弃使用比特币网络割肉离场。&lt;/p&gt;
&lt;p&gt;最终的结果就只能是在小圈子里自high.&lt;/p&gt;
&lt;p&gt;大幅降低交易成本，乃是世界趋势。这个最基本的经济原理，中本聪不懂，他就懂了个皮毛的自由市场。&lt;/p&gt;</description>
    </item>
    <item>
      <title>买不到好笔记本</title>
      <link>https://microcai.org/2020/04/07/missing-good-notebook.html</link>
      <pubDate>Tue, 07 Apr 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/04/07/missing-good-notebook.html</guid>
      <description>&lt;p&gt;笔记本市场市场竞争非常激烈，从业者都说本子难卖。然而我准备更新我用了4年的老本子的时候，却发现无本可买。&lt;/p&gt;
&lt;p&gt;为啥我要买一个新本子呢？因为不够用了。现有的笔记本内存只有16G, 想想现在的软件个个都是吃内存大户，干活编译代码的时候只能把浏览器关了。 有时候关浏览器还不够， 还得把运维工具也关了才能腾出内存。不然编译器就内存不足崩了。敲着代码还得上爆栈的时候，敲着代码还得 ssh 到服务器上调试的时候， 都非常的抓狂。&lt;/p&gt;
&lt;p&gt;所以我急需要 32G 内存的机器。&lt;/p&gt;
&lt;p&gt;这个本子买过来4年了，几乎就没拿它打过游戏，那闲置的GTX960M显卡一直浪费电源浪费重量浪费散热能力浪费￥。所以我希望下一个笔记本， 一定一定的不要有独显。这样可以更轻更薄更持久。&lt;/p&gt;
&lt;p&gt;微软吃 Surface Book 老本好多年了， 居然吃到后来吃退步了， 本来我打算更新下代的 SB 本，结果大失所望， 新一代的 Surface 居然屏幕分辨率缩水了。所以，为了轻便着想，下一台笔记本必须 4k 起步，最好 5k 8k 分辨率了。但是尺寸不能大， 大了不便携。 14寸是能接受的极限了。不能再大了。&lt;/p&gt;
&lt;p&gt;这3个筛选条件一套，已经是 0 符合要求的了。 何况我还有第四个要求，就是一定要 7nm Zen2 的 cpu 。。。。。&lt;/p&gt;
&lt;p&gt;好了， 直接啥也买不到了。&lt;/p&gt;
&lt;p&gt;多少钱都买不到。&lt;/p&gt;
&lt;p&gt;钱买不到的东西又多了一个，叫 程序员用的笔记本。&lt;/p&gt;</description>
    </item>
    <item>
      <title>1840 年来百年的屈辱换来的教训</title>
      <link>https://microcai.org/2020/03/19/learnt-from-1840.html</link>
      <pubDate>Thu, 19 Mar 2020 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2020/03/19/learnt-from-1840.html</guid>
      <description>&lt;p&gt;1840 年鸦片战争爆发, 到1949年, 中国开始了超过一百年的屈辱. 要说这一百多年的屈辱让这个民族学会了什么的, 那就是一定要工业化. 只有工业化, 才能救中国.&lt;/p&gt;
&lt;p&gt;为什么说只有共产党,才能救中国, 因为纵观1912年到1927年, 中国学习了西方的政治制度, 成立了几百个大大小小的政党, 但是没有救到中国. 归根结底的原因是, 这些政党不是工业党. 不是西方化, 就能救中国, 而是只有工业化, 才能救中国. 而共产党恰恰是唯一的一个工业党, 不仅仅是中国唯一的, 目前也是世界唯一一个工业党.&lt;/p&gt;
&lt;p&gt;苏联大部分国土都在北寒的冻土地带, 只有共产党带去了工业化, 苏联才崛起成为世界一极. 而苏共倒下后的俄罗斯, 沦落为一个资源国, 丧失了工业能力, 再也掀不起浪花.&lt;/p&gt;
&lt;p&gt;为什么说, 共产党是唯一一个工业党. 因为共产主义追求的, 是物质极大丰富, 而物质极大丰富需要追求极高的生产力, 极高的生产力只能靠工业化才能达到. 所以共产党从诞生的那一刻起, 就是一个坚定的工业党.&lt;/p&gt;
&lt;p&gt;而只有坚持发展工业, 才是真正的共产党. 这次抗疫深刻的揭示了一点: 工业部门不计报酬支援前线, 金融业和媒体汉奸辈出.&lt;/p&gt;
&lt;p&gt;而助中国赢得胜利的, 是强大的工业部门.&lt;/p&gt;</description>
    </item>
    <item>
      <title>3950X 再次拯救 Gentoo</title>
      <link>https://microcai.org/2019/12/31/mirror-efi-boot-partition.html</link>
      <pubDate>Tue, 31 Dec 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/12/31/mirror-efi-boot-partition.html</guid>
      <description>&lt;p&gt;镜像  EFI boot 分区。&lt;/p&gt;
&lt;p&gt;最近给电脑配了2个 nvme SSD 做 ZFS mirror . 每个盘都分了 2个分区， 一个 EFI system 分区， 一个 ZFS 分区。两个 ZFS 分区放到一个 zfs pool 里做镜像。但是 两个 EFI 分区。。。。怎么 mirror 呢？&lt;/p&gt;
&lt;p&gt;首先尝试了 raid1, 发现 raid1 在盘上建的话， 会破坏 ZFS。如果用分区建 raid1, 则分区类型被修改为 linux raid， 而不是 EFI system partition 了， 主板就不识别了。&lt;/p&gt;
&lt;p&gt;然后尝试的是挂到 boot1  boot2 两个分区， 后台写个脚本 rsync 拷贝同步。但是发现这个解决方案不够优雅。&lt;/p&gt;
&lt;p&gt;如果能建立一个没有 metadata 的 mirror 设备就好了。&lt;/p&gt;
&lt;p&gt;几经周折，发现了 dmsetup 命令， 可以建立不依托 metadata 数据的 mirror 分区。如果没有 metadata，就可以保留原汁原味的分区表，只是在系统层做数据 mirror， 无需主板的任何支持。&lt;/p&gt;</description>
    </item>
    <item>
      <title>3950X 再次拯救 Gentoo</title>
      <link>https://microcai.org/2019/12/27/3950x-save-gentoo-again.html</link>
      <pubDate>Fri, 27 Dec 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/12/27/3950x-save-gentoo-again.html</guid>
      <description>&lt;p&gt;多年前, 我抛弃了 AMD, 从 athlon 64 x2 升级到了 Sandy Bridge 的 Xeon E3-1230. 初代 E3 神U. 写了一篇文章, 说 i7 拯救了 Gentoo .   &lt;em&gt;虽然 E3 从名字上来说不是 i7 就是了, 不过后来我把 1230 升级到了 i7-4790.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;但是, 我从 E3 到 4790 的升级, 其实完全没有感觉到性能进步. 只是心理多了点安慰, 从老平台升级到新平台罢了. 那多 10%不到的性能提升, 实在是感觉不到. 后面的 6700 7700 8700 我都不再升级了.  都没有性能提升. 就守着老死的机器, 编译 Gentoo 越来越力不从心, 随着软件越做越大, 编译器越做越慢, emerge 需要的时间也是越来越大.&lt;/p&gt;
&lt;p&gt;虽然后来有在工作上, 升级使用了 AMD 的 1800X 和 2700X, 不过自个家里的电脑还是老态龙钟的 4790 , 连K都不带.&lt;/p&gt;
&lt;p&gt;因为 4790 用的是 DDR3 内存, 而接下来升级, 不管是 2700X 还是 i 家的 8700k 都要换全套了. 所以就一直耐心的等 3700X 的出现, 等  3700X 一发布我就升级!  结果到了年中的时候, 得知这次新一代U不仅仅是. 3700X 还有 3800X 和 3900X . 于是就等 7月7 的 3900X 了. 结果到六月底的时候, 又得到消息, 9 月发售 3950X !&lt;/p&gt;</description>
    </item>
    <item>
      <title>升级到4盘 raidz</title>
      <link>https://microcai.org/2019/08/23/upgrade-to-raidz.html</link>
      <pubDate>Fri, 23 Aug 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/08/23/upgrade-to-raidz.html</guid>
      <description>&lt;p&gt;上次折腾NAS, 使用了2个8T的盘建的 raid1. 速度不太满意. raid0 当然怕挂一个盘数据就没了, 索性就再买2个8T的, 组建4盘位raid5.&lt;/p&gt;
&lt;p&gt;这阵列升级啊, 一般的做法是, 先建 raid5 新阵列, 然后把数据拷贝过去, 然后&amp;hellip; 等等, 2个盘建什么 raid5. 那先把 raid1 取消镜像吧. 那也只有3个盘啊! 三个盘是能 raid5  问题是拷贝完了多一个盘, 而且我的目的是4盘 raid5.&lt;/p&gt;
&lt;p&gt;咋办?&lt;/p&gt;
&lt;p&gt;简单, 首先确实是需要取消镜像,  然后把剩下的3个盘, 和一个 假设备 一起建一个 4 盘的 raid5, 然后在数据拷贝进去之前, 把假设备从阵列里下线. 然后把数据从旧盘上拷贝到新阵列.&lt;/p&gt;
&lt;p&gt;最后完成拷贝后, 把旧盘替换到阵列里取代下线的假设备, 然后等待 raid5 重建完成. 即可大功告成.&lt;/p&gt;
&lt;p&gt;假冒设备的制作方法是&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-bash&#34; data-lang=&#34;bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;#dd bs=1 count=1 if=/dev/zero of=/fakedisk.img seek=8T&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;接着取消 sda sdb 的镜像&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-bash&#34; data-lang=&#34;bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;#zpool detach pool1 sda&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;然后创建新池并立即下线假盘&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-bash&#34; data-lang=&#34;bash&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;#zpool create pool2 raidz sda /fakedisk.img sdc sdd &lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;#zpool offline pool2 /fakedisk.img&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;#rm /fakedisk.img&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;接下来就是 zfs send 和 zfs recv 迁移数据&lt;/p&gt;</description>
    </item>
    <item>
      <title>sfp 形态 gpon 光猫失败</title>
      <link>https://microcai.org/2019/07/30/gpon-sfp-onu-failed.html</link>
      <pubDate>Tue, 30 Jul 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/07/30/gpon-sfp-onu-failed.html</guid>
      <description>&lt;p&gt;路由器上有一个 sfp 口,  有 sfp 模块形式的 gpon 光猫, 如果能用的话, 机柜里就少一个设备, 还少占用一个插座&amp;hellip;少接条网线&amp;hellip;..&lt;/p&gt;
&lt;p&gt;最近听网友说 TW2362H 这个猫便宜, sfp 模块的. 于是买了一个, 插入路由器. 过了一会启动完毕后就识别出来了.&lt;/p&gt;
&lt;p&gt;配置下路由器的网口 ip 地址, 然后 192.168.1.1 果然能进猫的页面.&lt;/p&gt;
&lt;p&gt;然而, 这简陋的界面犯愁了. 无从配置, 有个能填写 LOID 的页面, 完了.&lt;/p&gt;
&lt;p&gt;然后我才想起来, 我没有记录原来的猫的 LOID &amp;hellip;&lt;/p&gt;
&lt;p&gt;于是进入原来的猫的界面, 居然没找到能填 LOID 的地方&amp;hellip; 才发现, 这个猫没准是用 SN 认证的.&lt;/p&gt;
&lt;p&gt;然而这个猫的 web 并不能改 SN &amp;hellip;  更糟糕的是, 这个猫连查看 光信号功率的地方都没有. 都开始怀疑是不是gpon猫了.&lt;/p&gt;
&lt;p&gt;后来在俄国人的论坛上找了个固件. 刷进去后, 页面回来了. 倒是能看光功率了. 然后又学会了 telnet 进去用命令行强改 SN.&lt;/p&gt;
&lt;p&gt;最后在命令行下查看链路状态, 已经进入 O5 operational 状态了, 但是, 怎么拨号都无法成功.  pppoe 始终是无响应状态.&lt;/p&gt;</description>
    </item>
    <item>
      <title>准备上 3950x</title>
      <link>https://microcai.org/2019/07/16/prepare-3950x.html</link>
      <pubDate>Tue, 16 Jul 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/07/16/prepare-3950x.html</guid>
      <description>&lt;p&gt;听闻秒天秒低秒 i9 的 3950x 要在9月份发售了, 陪伴我多年的 i7-4790 终于可以退役了. 本来是打算9月进行退役的, 但是亲戚家有孩子今年开学需要用电脑了, 于是我就把电脑送给她了. 这样, 在9 月份到来前, 我就需要准备好一台备用电脑, 一台能随时升级到 3950x 的电脑.&lt;/p&gt;
&lt;p&gt;主板呢, 肯定是选 X570 芯片组的, 这样日后只需要换 cpu 即可. 选主板花了不少精力, 因为我不想要 SLI , 不要花冤枉钱给 sli 税. 然后没 sli 意味着显卡插槽是实打实的 x16 而不会一不小心变成 x8 或 x4 . 然后主板上的其他 pcie 都乖乖接 pch 上 不会像某个傻逼主板, 一共5 条 pcie 居然 4条是接 cpu 上的, 要 x4+x4+x4+x4 模式跑 sli 四卡交火. 剩下一条还是 x1 的.  神经病啊, x4 的话显卡性能还能发挥吗? 然后要是加别的扩展卡不是显卡就一定不能  x16 了么.&lt;/p&gt;
&lt;p&gt;然后选了好久敲定了几个符合要求的, 最后7月7号晚上9点发售的时候&amp;hellip;. 一切的选择都是徒劳的, 直接买了最便宜的首发主板 😂  . 也就是 MSI 的 X570-A PRO&lt;/p&gt;</description>
    </item>
    <item>
      <title>NAS 换 Gentoo</title>
      <link>https://microcai.org/2019/05/29/goback-to-gentoo.html</link>
      <pubDate>Wed, 29 May 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/05/29/goback-to-gentoo.html</guid>
      <description>&lt;p&gt;freenas 使用了一阵子，发现了几个严重的问题&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;软件严重缺乏&lt;/li&gt;
&lt;li&gt;插件需要使用 jails 而 jails 的网络居然不能使用宿主网络必须桥接&lt;/li&gt;
&lt;li&gt;桥接导致 mlx 驱动禁用网卡 tcp offload engine&lt;/li&gt;
&lt;li&gt;不支持 RDMA，atom cpu 性能弱，无法跑满万兆带宽。&lt;/li&gt;
&lt;li&gt;实际上很少使用 web 管理界面，多数情况下还是 ssh 上去直接敲命令&lt;/li&gt;
&lt;li&gt;性能差&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;要想性能好，Gentoo 少不了。于是计划 nas 改用 Gentoo。首先要做的事情就是确保 Gentoo 可以使用 ZFS。&lt;/p&gt;
&lt;p&gt;这个呢，我就先在自己机器上折腾了。首先重新编译内核，启用 zfs，安装好 zfs 工具，接着根分区的数据先备份，然后格式化为 zfs。然后拷贝回来。重启。完美启用 zfs。&lt;/p&gt;
&lt;p&gt;具体的迁移步骤为：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;首先进行规划，我的 nvme 盘有2个分区， nvme0n1p1 500M 为 EFI 分区。nvme0n1p2 117G 为 ext4 挂到 / 。首先使用 e2fsresize 命令缩小分区，然后在空闲的地方创建 nvme0n1p3 分区。 50G. 由于 liveusb 系统不支持 zfs，因此做完这些步骤后重启回原来的系统。&lt;/li&gt;
&lt;li&gt;zpool create -o mountpoint=none -R /newroot Gentoo nvme0n1p3 命令创建一个池。&lt;/li&gt;
&lt;li&gt;zfs create Gentoo/ROOT&lt;/li&gt;
&lt;li&gt;zfs set mountpoint=/ Gentoo/ROOT&lt;/li&gt;
&lt;li&gt;rsync -xav / /newroot&lt;/li&gt;
&lt;li&gt;完毕后重启，设定 root=ZFS=Gentoo/ROOT&lt;/li&gt;
&lt;li&gt;接着 zpool attach Gentoo nvme0n1p3 nvme0n1p2 命令，将原先的 ext4 所在分区直接以 mirror 模式加入 Gentoo 池。&lt;/li&gt;
&lt;li&gt;等待 resilver 完成&lt;/li&gt;
&lt;li&gt;zpool detach Gentoo nvme0n1p3 把 nvme0n1p3 这个分区分离出 Gentoo 池。&lt;/li&gt;
&lt;li&gt;fdisk 重新调整分区，把剩余的空间重新划给 nvme0n1p2&lt;/li&gt;
&lt;li&gt;zpool attache -e Gentoo nvme0n1p2 执行完毕后， Gentoo 池的大小就占满 nvme0n1p2 分区的大小了&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这样 Gentoo 池就是 117G 大小了。ext4 无损切换为了 zfs。&lt;/p&gt;</description>
    </item>
    <item>
      <title>根分区 ZFS 化</title>
      <link>https://microcai.org/2019/04/27/root-on-zfs.html</link>
      <pubDate>Sat, 27 Apr 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/04/27/root-on-zfs.html</guid>
      <description>&lt;p&gt;自从用 freenas 接触到了 ZFS, 我就爱上了 ZFS , 变得愈发不可收拾.  50买了2个 320G 的二手盘放公司玩 raidz.&lt;/p&gt;
&lt;p&gt;只是拿 zfs 挂数据的话, 只要编译好 zfs 内核模块和 zfs 命令行工具即可. 但是,如果要 zfs 当 root 文件系统的话, 则免不了一番折腾.&lt;/p&gt;
&lt;p&gt;为啥呢? 因为 zfs 不同于 legacy 文件系统, 他是集卷管理于一身的.&lt;/p&gt;</description>
    </item>
    <item>
      <title>无盘PC</title>
      <link>https://microcai.org/2019/04/26/go-diskless.html</link>
      <pubDate>Fri, 26 Apr 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/04/26/go-diskless.html</guid>
      <description>&lt;p&gt;自从上了万兆，把PC上的硬盘拆到nas上，让PC变成无盘的计划就开始执行了。真正的无盘需要 PXE，然而，同时也意味着现有的 NVMe SSD 成了摆设，因为上文提到的，我的 nas 因为主板关系， pcie 通道不足，无法插 M.2 了。所以现有的 ssd 还是继续在主板上服役。M2 只是一个非常小的接口， ssd 插上主板后和主板融为一体了，所以，姑且就算是主板自带的存储好了，如果只有 nvme 那也可以算无盘。&lt;/p&gt;
&lt;p&gt;既然保留了 nvme，那么无盘的工作就简单了，只需要将个人文件  aka &lt;code&gt;/home&lt;/code&gt; 目录放到 nas 上通过网络访问即可。由于在完成拷贝之前我就已经迫不及待的把硬盘插上 NAS 了，因此最初的无盘，我使用的 iSCSI。&lt;/p&gt;
&lt;p&gt;将 pc 原本的 4T 硬盘通过 iscsi 共享给 pc 自己。连 fstab 文件都不需要修改，因为 iscsi 连上去的磁盘居然还是 /dev/sda 。就好像只是换了一个 sata 口插一样的方便。&lt;/p&gt;
&lt;p&gt;但是， iscsi 只是 sata 线的替代品。我真正的目的，是要让我的数据全部由 ZFS 保管。只有 ZFS 才能让我感到安心。&lt;/p&gt;
&lt;p&gt;因此， 8T 氦气填充盘到了后，我就开始了乾坤大挪移。rsync 拷贝了数T的数据，把 旧硬盘上的数据全部转移到了 8T盘上的 ZFS。&lt;/p&gt;
&lt;p&gt;然后格式化旧盘，将旧盘作为 mirror 和 8T 的盘组成 raid1。&lt;/p&gt;
&lt;p&gt;4T 和 8T 怎么组 raid1？&lt;/p&gt;</description>
    </item>
    <item>
      <title>NAS 的 pcie 短缺问题</title>
      <link>https://microcai.org/2019/04/23/intel-pcie-shortage.html</link>
      <pubDate>Tue, 23 Apr 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/04/23/intel-pcie-shortage.html</guid>
      <description>&lt;p&gt;万兆网卡到货后，迫不及待的插上主板开机。&lt;/p&gt;
&lt;p&gt;当时就注意到了一个问题，怎么有一个 SATA 控制器变成了 2port controller 了。也就是说只有6个 sata 口了。&lt;/p&gt;
&lt;p&gt;然后和 pc 开始 iperf 测速。发现速度居然只有刚刚超过 2Gbps！！！
什么鬼？&lt;/p&gt;
&lt;p&gt;然后把 pc 上的那个卡换了个插槽，换到 pcie x16 的显卡插槽上了。原来是我这个卡放到了最后一个 pcie 2.0 x2 的插槽上（物理形态是 x16)&lt;/p&gt;
&lt;p&gt;再测，发现速度也是在  4Gbps 上下。然后进 nas 的 bios 发现， 我去！坑死我了。&lt;/p&gt;
&lt;p&gt;原来这个主板的 pcie 和 sata 是2选1通道的。 配置模式是 pcie x4 + sata x4, pcie x2 + sata x6, 或者 sata x8 但是禁用 pcie .&lt;/p&gt;
&lt;p&gt;我去，原来我只能折腾4盘位nas！ 一开始是 sata x8 但是只要 pcie 上插了卡，默认就是 pcie x2 + sata x6 模式。手动调节为 pcie x4 + sata x4 模式 后进系统， 果然达到了 9.4Gbps 的速度，然后改了 MTU 到 9000 就变成了 9.8Gbps 的速度了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>10Gbps 家庭云存储</title>
      <link>https://microcai.org/2019/04/22/10GbE-NAS.html</link>
      <pubDate>Mon, 22 Apr 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/04/22/10GbE-NAS.html</guid>
      <description>&lt;p&gt;在万兆内网达成后， 终于到了最重要的环节了，就是搭建一台支持万兆网络访问的 NAS。&lt;/p&gt;
&lt;p&gt;首先问自己一个最重要的问题：我家里有矿吗？&lt;/p&gt;
&lt;p&gt;显然，没有，所以，一切都要以够用为目标，而不追求高大上。&lt;/p&gt;
&lt;p&gt;所以，显然这次万兆够用为主，量力而行。&lt;/p&gt;
&lt;p&gt;第一个选择就是主板。主板我花了超过一周的时间去寻找，对比各种方案。&lt;/p&gt;
&lt;p&gt;当时的方案有3个：&lt;/p&gt;
&lt;p&gt;方案1：集成 Atom C3558 的主板。有ASRock和超微两个牌子都有提供。&lt;/p&gt;
&lt;p&gt;方案2：集成 Xeon D2123 的主板。&lt;/p&gt;
&lt;p&gt;方案3：使用 Ryzen 200GE 和 B450 主板。&lt;/p&gt;
&lt;p&gt;方案1 是因为主板提供了 pcie x4 的插槽，并且有 8 个 SATA 口（后来发现是个坑）
方案2 是以为主板已经集成了万兆网卡。
方案3 是因为毕竟是正常的桌面PC（虽然是低端的）有充足的扩展性。&lt;/p&gt;
&lt;p&gt;最后方案3被 PASS，因为发现需要 ECC 内存。&lt;/p&gt;
&lt;p&gt;方案2 因为主板价格超过五千被 pass。&lt;/p&gt;
&lt;p&gt;然后是选定方案1, Atom C3558。&lt;/p&gt;
&lt;p&gt;选方案1 是因为发现群辉8盘位的 DS1819+ 也是 Atom C3538 的方案。比 3558 还稍微渣了一丁丁呢。 而 DS1819+ 售价超过 8000 呢。&lt;/p&gt;
&lt;p&gt;虽然犹豫了一阵子，不过最后买了超威的 A2SDi-4C-HLN4F 这个款的主板，集成 C3558 cpu。CPU 被动散热，TDP 25w，花了 2333.&lt;/p&gt;
&lt;p&gt;然后就是最糟糕的，选机箱上了。&lt;/p&gt;
&lt;p&gt;因为家里有个小机柜，所以希望买个2U 高度的8个热插拔盘位的机箱。结果发现了一个严重的问题， 2U 高度的机箱，要么4盘位短机箱，要么8盘位长机箱。而长机箱是放不进去我的小机柜的。无奈买了个3U高度的。8个热插拔的机箱，长度40cm，再长点就要顶我机柜后盖了。价格 720 但是运费 60 。。。。&lt;/p&gt;</description>
    </item>
    <item>
      <title>多WAN平衡</title>
      <link>https://microcai.org/2019/04/04/multiWAN.html</link>
      <pubDate>Thu, 04 Apr 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/04/04/multiWAN.html</guid>
      <description>&lt;p&gt;曾经我也搞了两条宽带，见 &lt;a href=&#34;https://microcai.org/2016/12/07/use-neighbor-CMCC.html&#34;&gt;使用邻居的CMCC网络&lt;/a&gt; 。
然后利用路由器的loadbalance就可以使用多条线路了。
但是，问题恰恰在这里。效果并不好。因为2条宽带并不是一样容量的，对同一目标的访问速度也不尽相同。所以退而求次，选择了只把某些 cmcc 访问速度更快的目标通过 邻居网络出去。&lt;/p&gt;
&lt;p&gt;虽然我换了一个城市，然后选择了CMCC，也没有破解邻居的电信宽带wifi密码。但是多年前的失败经历还是让我感觉需要某种自动的机制自动的探测目标网络使用哪条线路是最快的。&lt;/p&gt;
&lt;p&gt;这就是 &lt;a href=&#34;https://github.com/microcai/smartproxy&#34;&gt;smartproxy&lt;/a&gt; 的了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>内网万兆达成</title>
      <link>https://microcai.org/2019/04/04/go-10GbE.html</link>
      <pubDate>Thu, 04 Apr 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/04/04/go-10GbE.html</guid>
      <description>&lt;p&gt;千兆用几年了？ 从我拥有的第一台电脑起，主板自带以太网口就是千兆的。十几年过去了，主板自带网口依旧千兆。&lt;/p&gt;
&lt;p&gt;千兆网和 1366x768 一样，都是业界毒瘤，停滞在一个“够用” 的幻想里止步不前。&lt;/p&gt;
&lt;p&gt;为了打破这个幻想，我最终决定，将家里的内网升级为 10G 光以太网。&lt;/p&gt;
&lt;p&gt;为啥用光纤呢？&lt;/p&gt;
&lt;p&gt;主要是我的 PC 所在的位置，距离 86网络端口面板有数米的距离，中间如果使用网线会非常的碍事。
所以我买了个 86 面板的 AP 把原来的网络端口面板替换了。然后 PC 再上一块 wifi 网卡即可。&lt;/p&gt;
&lt;p&gt;无线代替了有线。虽然链接速度显示为 1733Mbps 但是实测速度只有 600Mbps 而已。&lt;/p&gt;
&lt;p&gt;虽然不够用，但是我更不希望一条网线拖过去。&lt;/p&gt;
&lt;p&gt;就这么用了几个月，突然间，我发现了一种叫“隐性光纤” 的神器。有了这个，就可以把隐性光纤沿着墙角落走线到 PC，不就解决了难看碍事的问题了吗？&lt;/p&gt;
&lt;p&gt;但是，既然上了光纤，就不能继续千兆了，当然要万兆才行。&lt;/p&gt;
&lt;p&gt;兵马未动，粮草先行。买设备升级前，首先解决布线问题。&lt;/p&gt;
&lt;p&gt;于是买了 隐性光纤。然后开始换线。买了条新的网线，然后把新的网线和光纤一起绑在开发商装的网线上，然后从弱点箱抽，非常的困难，最担心的就是把线拉断在中间了。
虽然过程很艰难，但是最终把隐性光纤给换进去了。做好了以后，就是 86 面板AP 的边上还抽出来了一个细细的透明的钓鱼线一样的光纤，然后沿着墙角走线（透明胶大法）一路通到了 PC。另一头也已经从弱电箱出来放到网络机柜的边上了。&lt;/p&gt;
&lt;p&gt;第一步就算完成了，证明开发商虽然黑心，但是好歹线还是有用管子布的。。还是能换的，虽然很难抽。。。。&lt;/p&gt;
&lt;p&gt;但是，这么难抽，有没有把光纤拉断呢？&lt;/p&gt;
&lt;p&gt;于是买了红光笔和冷接套装还有万兆网卡。&lt;/p&gt;
&lt;p&gt;开始接 SC 头。&lt;/p&gt;
&lt;p&gt;冷接真的是个技术活，但是我最终搞定了。隐形光纤有2层皮，最外层是一层软塑料。用米勒钳的第二个口就可以剥掉。然后露出的裸纤我当时就直接上冷接头了。。还很纳闷为啥切割刀无法切割。我改用网线钳去切光纤了。。。。。 最后最好的线红光笔一测，怎么光点这么弱！？&lt;/p&gt;
&lt;p&gt;结果是错误的，要再剥掉一层。用米勒钳的第三个口剥离。当时我直接用第三口剥发现一切就断了。还以为是他第三口洞太小了。原来是要先用口2剥第一层，然后用口3 剥最后一层。&lt;/p&gt;
&lt;p&gt;最后最后才真正的露出了内层玻璃纤维。&lt;/p&gt;
&lt;p&gt;这个玻璃纤维放到切割器上真的一次就切的整整齐齐。&lt;/p&gt;
&lt;p&gt;然后塞入冷接头。红光笔一测，发现和买的成品跳线一样亮了。&lt;/p&gt;
&lt;p&gt;然后把路由器到交换机临时改插网线，把 SFP 模块借用给 PC 了。万兆网卡不出意外的兼容千兆光模块。&lt;/p&gt;
&lt;p&gt;这样就实现了PC千兆光纤到交换机。&lt;/p&gt;
&lt;p&gt;终于可以对 1733Mbps 的 wifi 说拜拜了。&lt;/p&gt;
&lt;p&gt;冷接光纤学会了，自然就不怕了，然后开始选万兆交换机。必须是无风扇的交换机&lt;/p&gt;
&lt;p&gt;这个是最大的一个问题，我最后停留在2个方案上。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;方案1： 使用 MikroTik CRS305, 带4个万兆光口和一个千兆口。千兆电口支持 POE 受电，意味着只要插入原来的交换机上就可以立即工作了。&lt;/li&gt;
&lt;li&gt;方案2： 使用华为 S1720-28GWR-4X 交换机。4个万兆口，24个千兆口，无风扇被动散热。没有 POE，意味着原先的交换机还得服役。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这两个方案都要原来的交换机继续服役，听起来是保护投资了，其实不然。 第一，交换机到交换机的带宽被限定 1G 可不是好事。第二，两台交换机还是占用了更大的空间，特别是方案2的话我其实不需要2台交换机给我扩充那么多端口。而方案1会有性能瓶颈。&lt;/p&gt;</description>
    </item>
    <item>
      <title>入DN42坑</title>
      <link>https://microcai.org/2019/03/11/dn42-connected.html</link>
      <pubDate>Mon, 11 Mar 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/03/11/dn42-connected.html</guid>
      <description>&lt;p&gt;近来把 家和公司三处地方的网络（2个家，乡下老家嘛）通过 tunnel 手段连接到了一起， 三个地方的 LAN 分配不同的私网网段，因此配置好路由表后，三处内网的机器就可以互相访问了。&lt;/p&gt;
&lt;p&gt;最初我使用的是添加静态路由，但是因为 vpn 是使用的点对点互联，而不是首先集中连到一个转发服务器上，所以需要配置路由表的路由器数量达到了4台，比较麻烦，关键是期间我还修改过私网使用的网段，结果每台路由器都要登录上去修改路由表， 非常麻烦。&lt;/p&gt;
&lt;p&gt;更为麻烦的是， 其中公司访问老家的 vpn 丢包比较大，如果通过家中的网路跳转访问， 反而更快。但是如果公司到家里的网络断开，还要希望自动的让他们之间的直链线路接手， 于是就折腾上了 OSPF 路由协议。&lt;/p&gt;
&lt;p&gt;当然，最开始我是使用的 bgp 协议， 让3台路由器相互建立邻居，但是bgp的邻居要手动配置，稍微麻烦了点，所以改用 ospf 协议。&lt;/p&gt;
&lt;p&gt;顺便还修改了 EdgeOS （Ubnt 的路由器使用的系统）让它支持配置 zerotier —— 是通过他内置的 configure 命令配置， 而不是 zerotier-cli 命令， 这样就可以在 Web GUI 上为 zerotier 虚接口建立 ospf。&lt;/p&gt;
&lt;p&gt;基本上 EdgeOS 就是 Debian Linux + Perl configure script.
所以，其实 EdgeOS 是可以移植到 x86 软路由上的。不过x86软路由可以直接使用 VyOS。&lt;code&gt;^_^&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;有了 动态路由协议，我只要设定老家到公司的vpn链路开销是 200, 而老家到家的开销是 80 ， 家到公司的开销是 80, 通过家中转访问的开销则只有 160，于是 ospf 的选路算法就会使用中转代替直联的那条vpn线路。如果中转的线路不可用， 则回退到直联模式。&lt;/p&gt;</description>
    </item>
    <item>
      <title>拿到了移动宽带的公网IP</title>
      <link>https://microcai.org/2019/03/01/cmcc-public-ip.html</link>
      <pubDate>Fri, 01 Mar 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/03/01/cmcc-public-ip.html</guid>
      <description>&lt;p&gt;闻觉 CMCC 手握 HKIX 宝剑， 想必连 HK 节点的 VPN 访问世界一定更快。世界的一部分一般在 HK 本地也有 CDN 节点，因此多数时候并不需要再从 HK 去世界绕一圈。于是买新房后，就办理了免费的CMCC宽带。不再向恶势力CT低头了。&lt;/p&gt;
&lt;p&gt;美中不足的是 CMCC 手头 ip 资源紧张，早早部署了 CGNAT，再经过猫一层 NAT，路由器又一层 NAT，访问个局域网都要3层NAT，再访问世界那就加1层VPN的NAT，达到了恐怖的4层NAT。&lt;/p&gt;
&lt;p&gt;于是第一件事情就是猫给改成了桥接模式，让路由器拨号。 猫就应该好好的做简单的光电转换的事情，搞什么非要把路由器的活也干了。这样下去TP-Link 岂不是要倒闭？ （虽然我不用 tp 的东西就是了）&lt;/p&gt;
&lt;p&gt;才少了一层NAT，还是深感不舒适。 特别是当需要从办公室连回家中的时候，只能靠服务器中转，明明在同一个城市，敲击键盘的每一个数字却都要绕地球一圈。&lt;/p&gt;
&lt;p&gt;NAT 破坏了网络的连接性，阻碍了 ipv6 的进程， 实在是十恶不赦。&lt;/p&gt;
&lt;p&gt;传统的NAT只是部署在家中，家里的NAT设备尚在用户掌握之中，大不了爬起来去路由器上敲击几条命令建立端口映射。&lt;/p&gt;
&lt;p&gt;但是 CGNAT 就是完完全全的罪恶涛天了。试问，一个只能打电话不能接听电话的手机，还叫手机吗？&lt;/p&gt;
&lt;p&gt;这辈子都不曾接过电话的人，总是觉得，能打电话就行了，接不到电话有屁关系。&lt;/p&gt;
&lt;p&gt;呵呵，你接不到电话，为了联系你，别人背后不知道做了多少工作，付出了多少成本！这种话，就好像一个生活在首都久了的人，没见过战争，就觉得别人去当兵去边疆守卫国家都是傻逼。&lt;/p&gt;
&lt;p&gt;但是没办法，ip地址不够，NAT 还是必要的，但是尽量让 NAT 只位于家中一层而已吧，运营商不要搞NAT了！&lt;/p&gt;
&lt;p&gt;CMCC 的宽带因为是送的， 直接打电话找它要是肯定没有的，人家宁可拆机也不会给你公网地址。&lt;/p&gt;
&lt;p&gt;所以想着，再办一条CT的宽带得了。只是一直没有行动，一是入户光纤乃开发商预埋，只有一根， 二是懒。 因为只要思想不滑坡， 办法总比困难多。&lt;/p&gt;
&lt;p&gt;忽然有一天，闲的无聊跑了一下 speedtest。其实一直都有跑，只是都没在意网速。那天就特别在意起来了，发现网速不达标。一直不达标。&lt;/p&gt;
&lt;p&gt;于是打了壹卍零捌拾陆。&lt;/p&gt;
&lt;p&gt;第二天修宽带的师傅就上门了。&lt;/p&gt;
&lt;p&gt;给他演示了一下，首先是 speedtest 测速，速度忽快忽慢。&lt;/p&gt;
&lt;p&gt;接着，禁用 ipv6 然后访问 &lt;a href=&#34;http://mirrors.zju.edu.cn/&#34;&gt;http://mirrors.zju.edu.cn/&lt;/a&gt; 下个iso，速度只有 50M，开 ipv6 访问， 速度 100M。&lt;/p&gt;</description>
    </item>
    <item>
      <title>IPv6 这几天的体验</title>
      <link>https://microcai.org/2019/02/13/ipv6-experience.html</link>
      <pubDate>Wed, 13 Feb 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/02/13/ipv6-experience.html</guid>
      <description>&lt;p&gt;如果只是家里折腾上了 ipv6 那不算 ipv6。网络这种东西一定要互联互通才算。最近把公司的猫也折腾了一下下，上了 ipv6。&lt;/p&gt;
&lt;p&gt;于是发现，在公司可以无缝访问家里的设备了。全部都在公网，无需端口映射之类的东西了。当然，家里也没有公网ipv4地址，映射了也白搭。&lt;/p&gt;
&lt;p&gt;有了 ipv6 后，发现所有的机器都突然没有了 NAT 墙。那一道无形中把整个世界割裂的墙消失了，只要知道 ip 地址，所有的设备都可以点对点互相访问。&lt;/p&gt;
&lt;p&gt;终于，端到端的透明性回来了。&lt;/p&gt;
&lt;p&gt;然而问题来了，因为每个设备 ip 不一样，以往一台机器弄个DDNS就好了，现在需要每台提供外访的机器都要跑一个 ddns。要是路由器能为局域网的机器批量更新 AAAA 记录就好了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>折腾 NAT64 实现 ipv6 only 内网</title>
      <link>https://microcai.org/2019/02/13/nat64.html</link>
      <pubDate>Wed, 13 Feb 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/02/13/nat64.html</guid>
      <description>&lt;p&gt;一直以来，虽然启用了 ipv6, 但是都是以 Dual Stack 模式运行。
你不知道，是服务器端不支持 ipv6 呢，还是客户端不支持，亦或二者皆有之。&lt;/p&gt;
&lt;p&gt;而且Dual Stack虽然解决了互联问题，但是看起来非常的丑陋，多个协议一起跑什么的，才不要呢！&lt;/p&gt;
&lt;p&gt;于是就有了搞 IPv6 Only 的想法。为了解决互联问题，还需要一台翻译的设备执行 NAT64。&lt;/p&gt;
&lt;p&gt;所谓 NAT64 就是让一台网关充当 ipv6 和 ipv4 的桥梁，把 ipv4 主机模拟成 ipv6 主机，供 IPv6 Only 的主机访问。
之所以可以这么做到，是因为 ipv6 拥有巨大的地址集。只要其中拿一小部分出来就可以包含所有的 ipv4 地址了。可以做到 ipv6 地址和 ipv4 地址一一对应，然后为这个一一对应执行 NAT 转换。&lt;/p&gt;
&lt;p&gt;只需要一台网关设备提供 Dual Stack 即可，LAN 内的机器都只要 IPv6 Only 了。&lt;/p&gt;
&lt;p&gt;要实现 NAT64 , 首先 需要 DNS64 的帮忙。
何为 DNS64 ? 要让 ipv4 的机器被访问到，首先需要他被转换为 ipv6 地址，做到这一点的就是 DNS64 。&lt;/p&gt;
&lt;p&gt;当向 DNS64 查询 dns 的时候，dns64 会检查域名是否有 AAAA 记录，如果有，就用他自己的 AAAA 记录里的 ipv6 地址，客户端就可以直接访问了，完美。 如果他没有 AAAA 记录，但是有 A 记录，就把这个 A记录里的 ipv4 地址给转换为一个 ipv6 地址，然后返回这个假的 AAAA 记录。&lt;/p&gt;</description>
    </item>
    <item>
      <title>中国移动原生IPv6配置</title>
      <link>https://microcai.org/2018/12/18/cmcc-ipv6.html</link>
      <pubDate>Tue, 18 Dec 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/12/18/cmcc-ipv6.html</guid>
      <description>&lt;p&gt;上峰拍了桌子, 要求 2018 年底之前商用 ipv6. 移动响应非常积极,已经可以用了.
ipv6 带来的第一个好处就是削除了NAT, 对万恶的私网ip地址说再见!&lt;/p&gt;
&lt;p&gt;在继续之前，首先讲下，ipv6 同 ipv4 在配置上的不同。&lt;/p&gt;
&lt;p&gt;对于家庭宽带，ipv4 是 pppoe 拨号的时候自动配置的。isp 给且仅给一个 ipv4 地址。
如果有多台设备需要上网，就需要使用一种叫 NAT 的技术进行网址共享。由于NAT隐藏了内网的细节, 在 isp 看来,所有的数据都是来自同一个 ip 地址的. 因此isp和家庭网关之间不需要什么路由协议.
但是 ipv6 得益于超长地址,不再需要节约地址了,于是内网仍然分配全球可路由地址. 这个时候, isp 其实就需要分配两次地址,一次是给家庭网关的WAN口,另一次是给家庭网关的 LAN 口.&lt;/p&gt;
&lt;p&gt;第一次分配,给 WAN 口分配, ipv4 和 ipv6 是一样的. 都是在 PPPoE 拨号完成后动态分配.&lt;/p&gt;
&lt;p&gt;只是, ipv4 时代, LAN 口地址是固定的一个内网地址. 而 ipv6 时代, 即使 ip地址再丰富, 运营商也不会给用户分配固定的 ip 地址, 因此, 需要一种 动态的给 LAN 口分配地址(准确的说是分配前缀)的协议.&lt;/p&gt;
&lt;p&gt;这个协议就是 DHCP-PD. LAN 口分配好前缀后, 整个子网就分配下来了, 至于这个子网里哪个机器用哪个地址, 那就和 isp 没有关系了. 而且实际上 isp 下发子网前缀后, 路由器其实是可以把 下发的子网再细分的, 这个适用于有多个 LAN 的情况.&lt;/p&gt;</description>
    </item>
    <item>
      <title>高并发服务器的静态内存分配策略</title>
      <link>https://microcai.org/2018/10/25/static-memory-allocation-made-server-fast.html</link>
      <pubDate>Thu, 25 Oct 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/10/25/static-memory-allocation-made-server-fast.html</guid>
      <description>&lt;p&gt;asio 的 async_accept 函数在高并发的时候，会发生遗漏 accept 的情况。根本原因在于，async_accept 回调的时候，已经 监听的socket已经没有执行 accept 操作了。
解决的办法就是投递多个 async_accept. asio 的 async_* 系列 函数通常只能投递一次，多次投递会发生未定义行为。async_accept 是为数不多的例外。&lt;/p&gt;
&lt;p&gt;通常在写一个 server 的时候，client 是采取 accept 一个就 make_shared 一个的做法。对于大量频繁的连接请求，make_shared 很快就会成为新的瓶颈。
在读 beast 的 example/http/fast_server 的时候，发现了 beast 对这个问题的解决方案，非常的聪明。&lt;/p&gt;
&lt;p&gt;beast 的做法就是，固定的 client 对象。每个 client 自己投递 async_accept 请求，把自己的 socket_ 投递给 async_accept。
async_accept 返回后， client 就对自己的 socket_ 执行处理， 该 read read，该 write 就 write。
直到这个 client 的请求全部处理完毕，连接也 shutdown 后， 它就再次投递 async_accept 进入下一个循环。&lt;/p&gt;
&lt;p&gt;在这个模式下，client 对象并没有被不断的 new 出来。 client 对象的数目是固定的。他利用了 async_accept 可以多次投递的 feature。
在超大量的请求下，该模式始终不会产生频繁的内存分配和释放请求，不仅仅加快了速度，而且也极大的避免了内存碎片。&lt;/p&gt;</description>
    </item>
    <item>
      <title>挖矿与创新</title>
      <link>https://microcai.org/2018/06/10/mining-and-startup.html</link>
      <pubDate>Sun, 10 Jun 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/06/10/mining-and-startup.html</guid>
      <description>&lt;p&gt;所谓挖矿，就是寻找一个随机数，是的区块头部和随机数结合后的 sha256 数值小于一个特定的目标数字。&lt;/p&gt;
&lt;p&gt;对于哪一个随机数能找到答案，没有人知道，也没有捷径，唯一的做法，就是一个一个的去试。&lt;/p&gt;
&lt;p&gt;比特币诞生也有9年了，9 年来，不断的有人尝试寻找捷径，但最终都没有找到，只能依靠暴力穷举随机数。
只要尝试的次数足够多，参与尝试的矿工足够多，大约每十分钟总会有一个幸运儿找到这样的随机数。
当他找到的时候，他将获得巨大的回报。
而当难度越来越高的时候，就有了矿池，为矿池工作的矿工，即使找到了，也只是获得平庸的奖励，
但是没有找到的矿工，同样获得了奖励。&lt;/p&gt;
&lt;p&gt;其实所谓创业，也是如此。没有人知道下一个独角兽会诞生在哪里。所有人都在无方向的试错。但是每隔一段时间，就有
一个人会找到那个正确的方向，获得巨大的奖励。
而当创业难度越来越高的时候，就有了公司。集合大家的力量去尝试寻找正确的解。&lt;/p&gt;
&lt;p&gt;所以创业成功，就和挖到比特币一样，没有什么秘诀。正如挖矿的算力越来越集中一样，创业也越来越成为少数人的特权。&lt;/p&gt;</description>
    </item>
    <item>
      <title>换用wireguard</title>
      <link>https://microcai.org/2018/03/20/switch-to-wireguard.html</link>
      <pubDate>Tue, 20 Mar 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/03/20/switch-to-wireguard.html</guid>
      <description>&lt;p&gt;之前把家里网络 &lt;a href=&#34;https://microcai.org/2018/02/22/network-reworked.html&#34;&gt;重新折腾&lt;/a&gt; 了一下, 用的是 走socks5 代理的 tcp 协议 openvpn. socks5 代理由 shadowsocks 提供.&lt;/p&gt;
&lt;p&gt;不过, 最近偶然在 LWN 发现了 wireguard 这个新型 VPN, 于是盘算着用起来看看效果.
结果一不小心, 发现了&lt;a href=&#34;https://github.com/Lochnair/vyatta-wireguard&#34;&gt;vyatta-wireguard&lt;/a&gt;, 这个可以让我的路由器也能用 wireguard!&lt;/p&gt;
&lt;p&gt;于是按照它的文档配置到了路由器上, 然后VPS那边也配置下.&lt;/p&gt;
&lt;p&gt;只是把路由器表里, vtun0 换成了 wg0 就好了, 其他的不需要换.&lt;/p&gt;
&lt;p&gt;完了之后测试了一下速度, 比 openvpn 的时候快了很多. 毕竟 UDP 嘛. vpn 这种东西还是适合 UDP 而不是 tcp 的.
而且在跑流量的时候, ping 的延迟不会增加. 如果是 tcp 则会因为发送窗口的关系, ping 的延迟会因为流量增加而迅速增加.
对网络的体验极其不好.&lt;/p&gt;
&lt;p&gt;当然, udp 模式的 openvpn 其实也可以, 只是 openvpn 已经被墙识别了, 不可能直接用 openvpn 啦.
wg 毕竟新鲜事物, 到墙能识别故意要很长一段时间了. 这段时间内都可以安心的啦.&lt;/p&gt;
&lt;p&gt;PS: 一开始担心机房屏蔽 UDP 包, 结果发现可以愉快的跑, 担心是多余的啦.&lt;/p&gt;</description>
    </item>
    <item>
      <title>UPS和直流供电的思考</title>
      <link>https://microcai.org/2018/03/05/hvdc.html</link>
      <pubDate>Mon, 05 Mar 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/03/05/hvdc.html</guid>
      <description>&lt;p&gt;为了在网络断电后还能使用, 我曾经给路由器配置 12v 直流 UPS. 但是, 随着我的网络扩展, 出现了更多的设备, 而且这些设备不再是12v电压供电的了, 而是出现了 24v 和 54v 供电的设备. 同时, 12v 供电的设备也增加了, 原来的 UPS 容量就显得捉襟见肘了. 我继续要对 UPS 进行一次升级.&lt;/p&gt;
&lt;p&gt;一劳永逸的解决方式, 其实是直接购买普通的 220v 逆变输出的 UPS. 但是, 生命在于折腾, 而且, 这种 UPS 效率很低, 因为 DC 经过一次逆变后, 还有再变压直流, 其实这中间的转换就属于脱裤子放屁多此一举, 除了带来毫无意义的能源损失. 除非用电设备是非交流电不能的, 比如 单相异步交流电机 然而我的设备里, 即使是网络存储器的散热风扇, 也是 12v的直流风扇而已. 所以, 直接购买UPS显然不够极客, 也不适合节能减排的今天.&lt;/p&gt;
&lt;p&gt;当然, 我也可以继续扩容 12v DC UPS. 多并联几个就好了. 然后使用 12v -&amp;gt; 24V 和 12v-&amp;gt; 48v 的 DC/DC 变换器来解决使用其他电压的设备供电.&lt;/p&gt;
&lt;p&gt;但是这样做会有2个问题, 第一个问题是, 这种寨牌的成品UPS并不能水平扩容. 第二个问题则是, 又要引入许多电压转换, 带来能源损失. 本身电池储能就有限, 不能肆意铺张浪费.&lt;/p&gt;</description>
    </item>
    <item>
      <title>网络重新配置</title>
      <link>https://microcai.org/2018/02/22/network-reworked.html</link>
      <pubDate>Thu, 22 Feb 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/02/22/network-reworked.html</guid>
      <description>&lt;p&gt;一直以来, 我用的都是基于 ss-redir 和 ipset + iptables 透明代理方式的科学上网. 但是 iptables 方式的上网, 其实还是不如 ChinaRoute 配合 VPN 来的爽. 因为只有 TCP 连接能被透明代理出去, UDP 和 ICMP 协议统统不能.&lt;/p&gt;
&lt;p&gt;但是 openvpn 这种协议实在是太过招摇, 所以早就被方校长盯上了. 不可不可.&lt;/p&gt;
&lt;p&gt;后来, 我想到了openvpn 可以透过纸飞机的代理再去连接远程服务器, 这样一来, 就解决了 openvpn 过墙问题.&lt;/p&gt;
&lt;p&gt;于是直接在服务器上安装 openvpn 然后设定为使用 tcp 协议, 监听 127.0.0.1 地址.&lt;/p&gt;
&lt;p&gt;然后在路由器上配置 openvpn , 只要配置文件里设定 socks-proxy xxx:1080 , 然后 remote 为 127.0.0.1 1189 就好了.
因为路由器是 ubnt ER-X, 自带 openvpn , 只需要自己编译 ss 就好, 不过因为最近买了个 群晖的 NAS, 于是懒得折腾交叉编译 ss 了, 直接在 NAS 上用 opkg install shadowsocks-libev 安装了纸飞机. 路由器上使用 NAS 上的 ss 代理就好了.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Immutable, RCU and Transnational Container</title>
      <link>https://microcai.org/2018/01/27/immutable-rcu-and-transactional-container.html</link>
      <pubDate>Sat, 27 Jan 2018 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2018/01/27/immutable-rcu-and-transactional-container.html</guid>
      <description>&lt;p&gt;在编写并发程序的时候，经常要面对共享数据结构的保护问题。
虽然 C++ 提供的 RAII 实现的各种 guard lock 模式，早就让“忘记解锁” 导致的死锁成为历史。但是，锁带来的性能损耗依然是我们不得不面对的问题。&lt;/p&gt;
&lt;p&gt;为了避免锁带来的开销，使用“无锁” 的数据结构似乎是个好主意。
然而事情的发展总是出乎所有人的意料。现代的多核CPU随着核数的越来越高，核与核之间的通信开销也变得越来越大。于是，所谓的“无锁” 容器，因为内部大量的“原子操作”变得越来越不适应于当前的时代。&lt;/p&gt;
&lt;p&gt;不使用原子操作，又想大并发，又想安全，唯一能想到的，就只有“不修改” 了。 只读的数据，永远不需要锁的保护。这也是为何当下的程序员越来越青睐函数式编程。&lt;/p&gt;
&lt;p&gt;然而，只有 const 没有 variable 的程序是根本不可能的。程序要运行，就得有变化。有变化，就不能使用只读的数据结构，不能只读，还是少不了要上锁。一锁，就离高性能大并发越来越远了。&lt;/p&gt;
&lt;p&gt;有没有既可以修改，又可以无锁，还不需要使用原子操作的办法呢？&lt;/p&gt;
&lt;p&gt;当然有啊，就是 RCU。但是 RCU 的局限性非常大，具体的来说就是，因为其赖以实现的原理导致了 RCU 只能是 list 容器。不能实现为更高效的 vector 和 hashmap 容器。&lt;/p&gt;
&lt;p&gt;RCU 先修改 关联节点的 next/prev 指针，使得 后续的读者，会跳过当前要操作的节点，然后等待一段时间后， 释放节点。这样，读可以全速并发进行。无需任何锁的介入。而只有 list 容器，才能在不使用原子操作和锁的情况下，安全的 Detach 掉一个节点。map 容器，因为要对 tree 重新排序，无法实现成 RCU 操作。&lt;/p&gt;
&lt;p&gt;即使 RCU 的读取速度再怎么好， list 就决定了，它在大元素量下注定的低性能。因此 rcu 即使在内核里，使用的也非常有限。只用在为数不多的 “读远大于写，而且容器元素不多” 的地方。&lt;/p&gt;
&lt;p&gt;这个虽然不是 RCU 的问题，而是 list 的问题，但是 RCU 注定只能使用 list。&lt;/p&gt;
&lt;p&gt;有没有办法让我最喜欢的 map/set/multiset/multimap/boost.multiindex 都能并发化呢？&lt;/p&gt;</description>
    </item>
    <item>
      <title>C&#43;&#43; 是最好的编程语言</title>
      <link>https://microcai.org/2017/11/04/c-is-the-best-language-forever.html</link>
      <pubDate>Sat, 04 Nov 2017 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2017/11/04/c-is-the-best-language-forever.html</guid>
      <description>&lt;p&gt;好的语言是怎么来的? 有人说, 是设计出来的, 有人说, 是抄出来的. newbie 说, 是实践来的.&lt;/p&gt;
&lt;p&gt;什么是实践呢? 实践, 就是摸石头过河, 吸收合适的, 抛弃不合适的. 这不就是进化吗?&lt;/p&gt;
&lt;p&gt;正如好的物种是进化来的一样, 好的语言也是进化来的.&lt;/p&gt;
&lt;p&gt;物种的进化, 首先是要适应已有的环境, 然后才是展望未来, 设法适应未来的环境. 即使某些功能器官已经不再需要, 仍然保留着进化的痕迹.
进化是不可逆的. 如果一开始因为环境因素, 进化出的生物特性在后来的环境变化中是非常有害的, 进化却不能推倒重来. 只能继续在这个不利的基础上改进.&lt;/p&gt;
&lt;p&gt;认识到这一点, 再回过头来审视 C++ 语言.  C++ 语言的许多缺陷, 来自对 C 的兼容, 或者确切的说, 是因为从 C 语言开始进化的, 对C的兼容, 就是进化的痕迹.
进化不能推倒重来, 只能在 C 这个不利的基础上改进.&lt;/p&gt;
&lt;p&gt;但是, C 的不利, 是站在今天的角度看的. 在当时, C 是最成功的语言. 兼容 C, 是最有利于发展的. 从 C 开始进化, 在当时就是最好的选择. 而进化, 就是当年最优秀的物种才得以继续发展演化.&lt;/p&gt;
&lt;p&gt;C 当年是最好最成功的语言, 那么进化就会发生在 C 的身上, 而不是其他语言的身上. 正如远古的猿类进化成了人, 同时也进化出了猴子一样, 远古的 C 语言进化出了 C++, 也会有顽固分子选择止步不前, 就有了现在的 C. 猴子当然不如人, 但是猴子也会存在. 所以 C 会继续存在. 但是真正的发展是看C++的.&lt;/p&gt;</description>
    </item>
    <item>
      <title>不停机迁移</title>
      <link>https://microcai.org/2017/06/19/non-stoping-db-mitigrade.html</link>
      <pubDate>Mon, 19 Jun 2017 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2017/06/19/non-stoping-db-mitigrade.html</guid>
      <description>&lt;p&gt;设计一套系统的时候， 最初的数据库结构总是不能适应未来业务的发展变化。经常需要调整数据库的表结构以适应新的业务需求或调整逻辑结构。&lt;/p&gt;
&lt;p&gt;为此，需要让系统能支持不停机迁移。不停机迁移，用户0感知的，完成数据库升级。要做到这点，首先要做到程序本身的热更新。&lt;/p&gt;
&lt;p&gt;如果是 php 之类的脚本语言编写的服务器端程序，热更新实现起来倒也轻松容易。但是既然是我这个c++佬出来写文章， 一定是关注的c++编写的服务器端程序的热更新。&lt;/p&gt;
&lt;p&gt;systemd 提供了一个热更新的新思路。就是让 systemd 持有 listen socket。然后fork出服务进程。
进程重启， listen socket 并没有销毁，因此用户依然可以在进程关闭期间发起连接。期间创建的连接，在进程启动后会被处理。
用户唯一能感知到的就是重启期间处理有一定的延迟。&lt;/p&gt;
&lt;p&gt;支持 systemd 的 sccket activation 就实现了热更新的第一步。&lt;/p&gt;
&lt;p&gt;接下来才是重点。使用 socket activation 的必然要求就就是重启迅速。新进程要迅速完成启动准备，并进入服务状态。连接总是被 hold 住，响应不及时，用户看来也是停机。&lt;/p&gt;
&lt;p&gt;如果要修改数据库结构， 重启时就是修改的时机。这就要求，对数据库 schema 的修改必须要立即完成。
那么，什么样的操作能立即完成呢？&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;增加一个允许 NULL 字段。
删除一个字段。
重命名一个字段。
删除一个索引
创建一张新表
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;什么样的操作要避免呢？&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;增加一个非空字段
新建一个索引
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;并非所有的操作都要安排在程序重启期间进行。可以在重启前就执行。这就要求，对数据库的修改，必须保证旧程序代码兼容。如果不兼容，就首先热更新一个能同时兼容
旧库和（即将更新的）新库的程序。接着更改数据库。使用这种方式，可以放宽一个要求， 就是只要不（长时间）锁表的操作，都可以进行。例如，pg 的并发新建索引。&lt;/p&gt;</description>
    </item>
    <item>
      <title>使用异常实现cache</title>
      <link>https://microcai.org/2017/04/09/simple-cache-container.html</link>
      <pubDate>Sun, 09 Apr 2017 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2017/04/09/simple-cache-container.html</guid>
      <description>&lt;p&gt;异常用来做错误处理的时候，程序到处都是 try  cache ，代码十分的丑陋，我是不怎么喜欢的，我喜欢 asio 那种用 error_code  汇报错误 —— 不传 ec 的时候就抛异常，传就不抛，改为写入错误到 ec。&lt;/p&gt;
&lt;p&gt;但是，异常用来做流程控制，又特别的好用。流程控制，无非顺序、选择、分支和循环。在 c++里，又比 C 多了一个异常。在嵌套很深的地方，跳出逻辑，除了异常，就没有其他更好的办法了。&lt;/p&gt;
&lt;p&gt;在编写软件的时候，时常需要对一些数据做 cache。在使用的时候，要先检查 cache，存在则使用 cache ，不存在则按照老办法办，然后存入 cache。&lt;/p&gt;
&lt;p&gt;每次使用前都进行判断， 污染了快速路径的代码，对有简洁洁癖的程序员来说，内心是十分的纠结的。&lt;/p&gt;
&lt;p&gt;这个时候， 你就需要 异常。将 cache hit 作为正常的流程进行编写， 假定全部的数据都是在 cache 里的。这万一发生了 cache miss ， 则抛出异常，并在异常处理重新载入数据。然后重启处理。&lt;/p&gt;
&lt;p&gt;说到重启处理， 在 Windows 的 SEH 里，存在 &lt;code&gt;EXECEPT_CONTINUE_EXECUTION&lt;/code&gt; 这个异常处理的结果， windows 看到异常处理函数返回这个，就会回到发生异常的地方重新执行。然而这毕竟是一个 Windows 系统特有的 SEH ， 而且依赖底层CPU提供的机制。 编写C++是断然不能使用这套机制的。&lt;/p&gt;
&lt;p&gt;思考的最终结果，就是下面这样的结构&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;
for (int =0; i &amp;lt; retry_times ; i++)
{ 
    try  
    {
            auto  v = cache_map_sometype.get_cache(key);
            // process with v ....
            ........
    }  
    catch(cache_miss&amp;amp;)
    {   
           // load v from other resources, database, filesystem, network, etc.
           ......
            cache_map_sometype.add_cache(key, v);
            contine; // NOTE about this.
    }
    break;  
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;在正常处理流程里， 执行到最后会有个 break 退出 for 循环。所以 for 循环在 cache hit 的状态下只执行一次。在 cache miss 的时候， catch block 里最后有一行 continue 。 于是就重启处理过程了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>免费版的 PrimoCache</title>
      <link>https://microcai.org/2017/02/10/fix-slow-hdd-aka-free-version-of-PrimoCache.html</link>
      <pubDate>Fri, 10 Feb 2017 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2017/02/10/fix-slow-hdd-aka-free-version-of-PrimoCache.html</guid>
      <description>&lt;p&gt;去年DIY一个 NAS. 其实就是台 MINI PC. 自带一个很小的 mSATA SSD 用来装系统, 然后外接了一个大 HDD 做存储.&lt;/p&gt;
&lt;p&gt;问题在于, 这个 大 HDD 是渣机械, 一开迅雷, 硬盘就被 100% 占用! 然后导致整个 OS 响应迟缓. 然后因为 HDD 写入速度不足, 导致迅雷下载速度 0 . 磁盘疯狂写入.&lt;/p&gt;
&lt;p&gt;后来下了一个 PrimoCache ( 以前叫 FancyCache ) 后, 问题解决了.&lt;/p&gt;
&lt;p&gt;然而只有 60 天试用期. 60天过去了, 我又得回到原来的老状态了吗? 非也!
我发现了一个叫 StarWind 的 iscsi software target. 只要装了 StarWind 就可以把 PC 变成一个 iscsi 的目标存储设备.
接着, 因为装的是 Windows Server 2012 R2 系统, 所以是自带了 iscsi 发起程序的. 于是把 127.0.0.1 的目标连起来.
于是写入路径就变成了 本地磁盘 D -&amp;gt; windows iscsi -&amp;gt; 本地网络 -&amp;gt; StarWind -&amp;gt; 原本地磁盘 D&lt;/p&gt;</description>
    </item>
    <item>
      <title>通知到轮询线程</title>
      <link>https://microcai.org/2017/01/15/pull-work-with-notify.html</link>
      <pubDate>Sun, 15 Jan 2017 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2017/01/15/pull-work-with-notify.html</guid>
      <description>&lt;p&gt;在腐都工作也有大半个月了。工作过程中，遇到了一个轮询+通知的消息模式。所以要轮询，是因为通知是不可靠的。
所以要通知，是因为轮询是不及时的。既要保证及时，又要保证可靠，就只能轮询和异步通知一起上。&lt;/p&gt;
&lt;p&gt;因为异步通知的时候，会把轮询需要获得的状态一并携带上了。所以，获得通知后只是取消定时器，让轮询线程立即唤醒干活肯定是。。。 可以的但是有点浪费。如果在异步通知线程里直接调用处理呢，就要把处理的东西从轮询的线程里扣出来，这样轮询的代码就不直观了。&lt;/p&gt;
&lt;p&gt;因为使用的是 asio 的 stackless coroutine。&lt;/p&gt;
&lt;p&gt;不过，如果改造下 timer,  async_wait 的时候是可以2个返回值的回调呢？ 一个 ec 一个 通知的消息呢？&lt;/p&gt;
&lt;p&gt;于是只要在 yield timer.async_wait 下面判断下 ec ，然后 yield async_pull&lt;br&gt;
如果 ec = aborted 那就不执行 yield async_pull . 直接把第二个参数看成是 async_pull 返回的。&lt;/p&gt;
&lt;p&gt;这样就可以在不改动轮询代码的情况下，插入了异步通知。&lt;/p&gt;
&lt;p&gt;结果伪造代码表示如下下&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;operator&lt;/span&gt;()(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code ec, some_type_of_pull pulled_message)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	reenter(&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;while&lt;/span&gt;(is_timeout()) &lt;span style=&#34;color:#75715e&#34;&gt;// 超时后不再轮询
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			timer.expires_from_now(pull_interval);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			yield timer.async_wait(&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);_
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;!&lt;/span&gt;ec)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				yield async_pull_message(object_id, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			}&lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;(ec &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;opertion_aborted)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#75715e&#34;&gt;// 强行没错误！
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				ec &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;!&lt;/span&gt;ec)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#75715e&#34;&gt;// 处理轮询消息
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			}		
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}	
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;wake_up&lt;/span&gt;(some_type_of_pull message)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	timer.wake_up(message);_
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;因为 timer 的回调的第二个参数是得万能类型，所以 timer 其实是个模板类。&lt;/p&gt;</description>
    </item>
    <item>
      <title>TCP拥塞控制</title>
      <link>https://microcai.org/2016/12/27/TCP-conguestion.html</link>
      <pubDate>Tue, 27 Dec 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/12/27/TCP-conguestion.html</guid>
      <description>&lt;p&gt;BBR 为啥要对包的发送时机进行调度呢? 是为了防止缓存堆积.
比如对方的接收速率是  1MB/s . 你的本地发送速率可以达到  1.1GB/s .
RTT = 500ms, 窗口大小是  500KB.
好,  现在有  500KB 的数据要发送, 那么你是一次性发出呢? 还是把  500KB 分到 0.5s 的时间内匀速发出?
500KB 是  500 个包. 在 10Gbps 的本地链路上, 你只要 0.5ms 就全部发出去了.
而对方是 1MB/s 的速度, 所以需要  500ms 的时间接收.
这一速率不匹配, 是靠 中间设备的  &amp;ldquo;缓存&amp;rdquo; 来吸收的震荡.
在 BBR 出现前, 都是这么做的,  就是窗口大小的数据, 一股脑的全丢出去了.
靠链路上的各种交换机和路由器的缓存来吸收震荡.
但是 BBR 不这么干 .
BBR 认为, 既然带宽只有  1MB/s 而你的窗口 500KB, 要发 500KB 数据过去, 就是要把 500KB 均匀的铺到 1MB 里.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Yaoi-city-here-I-come</title>
      <link>https://microcai.org/2016/12/27/Yaoi-city-here-I-come.html</link>
      <pubDate>Tue, 27 Dec 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/12/27/Yaoi-city-here-I-come.html</guid>
      <description>&lt;p&gt;腐都我来啦!&lt;/p&gt;</description>
    </item>
    <item>
      <title>使用邻居的CMCC宽带加速</title>
      <link>https://microcai.org/2016/12/07/use-neighbor-CMCC.html</link>
      <pubDate>Wed, 07 Dec 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/12/07/use-neighbor-CMCC.html</guid>
      <description>&lt;p&gt;基于某些特殊原因，我知道邻居家的wifi密码。&lt;/p&gt;
&lt;p&gt;但是他家信号在我家虽然能收到，但是比较弱。所以一直没用。最近从newbie获赠了一个叫 Ubnt AirMAX 的山寨产品，有个定向天线。
这使得我可以在家接收邻居家的信号了。于是就开始用啦！&lt;/p&gt;
&lt;p&gt;先上图。&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/fakeairmax.jpg&#34; &gt;
&lt;p&gt;这是在阳台装好的效果。这货还支持 POE 供电，非常不错，网线到就可以干活了。&lt;/p&gt;
&lt;p&gt;邻居家使用的是CMCC的网络，这是我要连上他家网络的主要原因。因为据说 CMCC 的出国带宽好啊! 而我呢，则是重度的墙外网络使用者。
所以想用他家的网络来加速我的国外访问。&lt;/p&gt;
&lt;p&gt;连接的办法是 ERX -&amp;gt; POE交换机 -&amp;gt; 山寨网桥。&lt;/p&gt;
&lt;p&gt;POE 交换机是网管交换机，所以划了单独 VLAN 给网桥。我用了 port 2 接的网桥，划分了 vlan 3389, pvid = 3389 。 由于我用的 port 7 接的 ERX。port 7 做 trunk 端口，允许通过  3389 即可。 ERX 的 eth2是接入的交换机，所以在 eth2 上创建 vlan 3389 即可。在 eth2.3389 接口上配置 ip 地址，静态 192.168.100.2 。因为邻居家是  192.168.100.0/24 的网络嘛。&lt;/p&gt;
&lt;p&gt;然后在 ERX 上 ping 192.168.100.1 成功。意味着能连上邻居的路由器了。&lt;/p&gt;
&lt;p&gt;接着为 eth2.3389 接口开 NAT 伪装。这是必要的。因为我不想在邻居家的路由器上配置静态路由表 —— 因为他家的路由器并不支持动态路由协议 —— 当然我也不希望我家内部的网络被他访问到。&lt;/p&gt;</description>
    </item>
    <item>
      <title>错误配置的路由器</title>
      <link>https://microcai.org/2016/12/06/misconfigured-router.html</link>
      <pubDate>Tue, 06 Dec 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/12/06/misconfigured-router.html</guid>
      <description>&lt;p&gt;企业专线宽带通常会分配多个固定IP，一般是 4 个。也有的是 8 个。如何使用这多个IP地址也是一门学问。&lt;/p&gt;
&lt;p&gt;我见过的多数企业，对于多个IP的使用基本上就2个模式。&lt;/p&gt;
&lt;p&gt;模式1：只使用一个。（通常负责人还会抱怨给那么多地址干嘛，一个就够了，多的不要了，给降价吧！）&lt;/p&gt;
&lt;p&gt;模式2：作为NAT地址池。提高大并发下的NAT效率。（这个负责人通常遇到上面那种人会觉得对方没文化，企业上网人数多，NAT端口不够用，自然要多个IP来平衡。）&lt;/p&gt;
&lt;p&gt;在这2个模式下，如果企业还要搭建公网服务，则是在路由器上使用 DNAT。多个服务器的话就会把多个IP拿来做 1:1  映射。就是 ip1 的流量全部转给服务器1, ip2 的全部转给服务器2。这个叫 1:1 NAT。&lt;/p&gt;
&lt;p&gt;其实这就是把在家用 TP-LINK 的时候的经验套到了企业网络管理中导致的。&lt;/p&gt;
&lt;p&gt;正确的做法是，把公网地址直接配置到服务器上去。剩下的配置给路由器做NAT池带办公区的电脑上网。&lt;/p&gt;
&lt;p&gt;如果服务器数量比较多，就多购买IP，每个IP的费用其实相当便宜（对拉的起企业专线的公司而言），并不会比服务器消耗的电费更多呢。&lt;/p&gt;</description>
    </item>
    <item>
      <title>中国电信原生IPv6配置</title>
      <link>https://microcai.org/2016/11/29/telecom-ipv6.html</link>
      <pubDate>Tue, 29 Nov 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/11/29/telecom-ipv6.html</guid>
      <description>&lt;p&gt;目前电信已经商用 ipv6 网络了，ipv6 的好处你懂得。&lt;/p&gt;
&lt;p&gt;在继续之前，首先讲下，ipv6 同 ipv4 在配置上的不同。&lt;/p&gt;
&lt;p&gt;对于家庭宽带，ipv4 是 pppoe 拨号的时候自动配置的。isp 给且仅给一个 ipv4 地址。
如果有多台设备需要上网，就需要使用一种叫 NAT 的技术进行网址共享。&lt;/p&gt;
&lt;p&gt;但是 ipv6 地址有 128位那么长，世上每一粒沙子都能分配一个 ipv6 地址，意思就是分配不完的！
所以，运营商就很大方的给给你许多许多的 ipv6 地址了，也就不需要 NAT 啦！&lt;/p&gt;
&lt;p&gt;由于不需要 NAT，因此在使用路由器共享上网的时候，配置就变得不同了。
使用 ipv4 的时候，路由器负责拨号，然后使用它自己的 DHCP服务器给局域网里的其他机器分配一个私有地址。
而到了 ipv6 的时候，情况就有所不同了，因为 ipv6 没有 NAT ，自然局域网里的机器并不需要也不能分配私有地址，而是需要获得一个全球唯一的地址。但是路由器也不是随便给你分配一个地址就行的，随机生成的地址并不一定能保证唯一性，而且也无法路由。isp 怎么能帮你路由一个随机的地址呢？
所以到了 ipv6 的时候，配置办法就变了一下。首先，路由器从 isp 获得 ipv6 地址，这个地址还是老办法，dhcp 自动获得。所以是 dhcp 从 pppoe 自动获得了 v4 和 v6 地址。这个没什么不同。
但是接下来就有不同点了。&lt;/p&gt;
&lt;p&gt;接下来，LAN 口的地址配置开始不同了。 ipv4 是固定一个私有的 LAN 口地址，而  ipv6 则使用 dhcp-pd 这个技术从 isp 获得一个 公网地址。因为一般来说一个接口发 dhcp 请求是为了给自己获取地址，而这次，是给别的接口获得地址，所以这个叫 delegate 。又因为，isp 回给你的呢，是一个网段，而不是一般的dhcp给你一个地址。所以这个叫 prefix delegate.&lt;/p&gt;</description>
    </item>
    <item>
      <title>高速转发是如何实现的</title>
      <link>https://microcai.org/2016/11/26/how-non-blocking-forwarding-achieved.html</link>
      <pubDate>Sat, 26 Nov 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/11/26/how-non-blocking-forwarding-achieved.html</guid>
      <description>&lt;p&gt;以太网发展到如今，已经出现了 400Gbps 的传输速度了。在这个传输速度下，实现无阻塞转发，需要达到的转发性能要达到 579.2Mpps x 端口数，要实现无阻塞转发所需要的背部带宽达到 800Gbps x 端口数。没有任何已知的系统总线能提供如此大的带宽。&lt;/p&gt;
&lt;p&gt;那么，高速转发是如何实现的呢？&lt;/p&gt;
&lt;p&gt;首先，将问题分解，一次转发分解成多个动作，然后看这些动作如何实现。&lt;/p&gt;
&lt;p&gt;第一，网络接口收到数据包。这里，计算机主机的做法是使用中断进行通知。然而路由器是专门的硬件，它没有除了转发数据包以外的任务。因此它不需要使用中断。而是直接CPU不停的轮询。不仅仅如此，它为每一个端口分配一个CPU。为了降低成本，提高速度，这个专门的干活的CPU通常是一块 ASIC 而不是一块通用 CPU。这个专门的芯片就叫转发引擎吧。他就是专门设计的一个只用来干包转发这一个活的CPU。这样就解决了发收包的瓶颈。&lt;/p&gt;
&lt;p&gt;第二，对每个收到的包，要进行查表，决定转发的目的端口。对交换机来说，是以 MAC 地址查表，对三层交换机或路由器来说，是以IP地址进行查表。那么查表速度就成了关键。对内存来说，他的输入是内存地址，输出是该地址的内容，但是，有另一种内存，叫 CAM , Content Addressable Memory，它的输入是内容，输出是内容的key。CAM 能实现硬件查操作，硬件单周期查表。不过 IP 地址和 MAC 地址有些许不同， MAC 地址使用的是精确匹配，而IP地址是用的最长前缀匹配。所以三层转发需要使用 TCAM。 TCAM 就是 三态CAM, 除了 0 和 1 还有个比较状叫 Don&amp;rsquo;t Care。这样 TCAM 的匹配结果是有多个的，但是只有第一个匹配结果会输出，只要匹配内容预先按照掩码长度排序就可以实现最长前缀匹配了。&lt;/p&gt;
&lt;p&gt;完成查表，知道了目的转发端口后，这个数据就该通过 内部背板 发送到另一个端口了。最初背板带宽是一个总线结构，但是随着端口速率的上升，总线结构的背板早就无法支撑交换机需要的巨大带宽了。每个端口两两互联，倒是能解决了带宽问题，但是这意味着端口连线太多。&lt;/p&gt;
&lt;p&gt;因此现在路由器使用的是 “交换式背板”。结构如下图所示：&lt;/p&gt;
&lt;p&gt;交换式背板是一块纯电路。在每个交叉的位置使用了开关晶体管控制通断。从图片上可以看到 1 2 3 4 发和  1 2 3 4 收可以通过开关实现完全独立的互连。注意这里的 发和收是编号一样的。1 号发和1号收其实就是1号端口。&lt;/p&gt;
&lt;p&gt;这样通过开关控制，所有的端口都可以在需要的时候建立点对点连接。由于是点对点链接，因此互联线路的带宽实际上并不会比以太网更高。设计难度就大大降低了。&lt;/p&gt;
&lt;p&gt;然后到了发送端口，发送端口再根据 QoS 进行排队然后发出或者列队太长就丢弃。&lt;/p&gt;
&lt;p&gt;这样，就可以完全在现有的技术条件下，完成超高速的交换。看起来几百 Tbps 的背板带宽实际上不如 PCIE x16 更有难度。&lt;/p&gt;</description>
    </item>
    <item>
      <title>死在以太网发展道路上的网们</title>
      <link>https://microcai.org/2016/11/24/the-networks-that-died-in-the-hands-of-etherenet.html</link>
      <pubDate>Thu, 24 Nov 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/11/24/the-networks-that-died-in-the-hands-of-etherenet.html</guid>
      <description>&lt;p&gt;记得 Robert Metcalf（以太网的发明者）说过如果有技术最终替代了以太网，那么它还是会被叫做“以太网” ，所以以太网永远不会消亡。&lt;/p&gt;
&lt;p&gt;以太网，诚如它所言，真的像火凤凰一样，不断的涅槃重生，从最初的 3Mbps DIX 以太网到最新的  400Gbps 以太网。历经 10Mbps 100Mbps 1000Mbps 10Gbps 40Gbps 100Gbps 的磨练，一次次的幻化重生。然而，都叫以太网。并在这不断的重生中，一路排除掉了全部的竞争对手。&lt;/p&gt;
&lt;p&gt;以太网到底凭什么，有如此顽强的生命力，每一次重生都宣布着对手的永久性死亡。先不忙着下结论，让我们看看， 以太网每次重生，都干掉了那些对手吧。&lt;/p&gt;
&lt;p&gt;以太网初生的时候，有个重量对手， ARCnet。ARCnet 提供了 10Mbps 的总线结构的连接。所有接到同轴电缆上的机器共享 10Mbps 的带宽。这点和以太网是一致的。不一致的地方在于以太网使用 CSMA/CD 在同轴线上竞争使用网络，而ARCnet则使用令牌决定谁来发送数据，减少了冲突，在主机较多的情况下效率更高。因此最初和以太网的较量中，还略占优势。得益于ARCnet的协议简单，其接口控制卡的售价也低于以太网。因此在竞争中占据了优势。&lt;/p&gt;
&lt;p&gt;但是优势很快就消失了，因为基于 非屏蔽双绞线 的以太网诞生了。非屏蔽双绞线大幅降低布线成本。同时网桥的出现隔离了冲突域。而且在2对双绞线上传输能同时实现首发，也就是实现了全双工通信。这些优点使得ARCnet的竞争中败下阵来。&lt;/p&gt;
&lt;p&gt;80 年代末的令牌网已经能提供 16Mbps 的产品同以太网较量。令牌网不仅速度快于以太网，而且由于以太网使用CSMA/CD导致冲突发生时效率地下，不管怎么看以太网都处于竞争劣势。但是拯救以太网的“交换机”神奇的出现了。交换机隔离了冲突域，每台主机同交换机之间都能独享这一条链路上的带宽。由于取消了总线结构，星型结构使得布线和移动网络端口都变得轻而易举。而且容易定位网络错误。使得以太网相对竞争者提供了更好的优势。更重要的是，它保护了现有的投资。只要新增交换机，就可以提升网络质量，而不需要大飞周张的更换设备。&lt;/p&gt;
&lt;p&gt;接着，快速以太网适时发布。100Mbps 的速率即使放到今天都不显得缓慢呢！更重要的是， 100Mbps 的以太网提供了绝佳的向后兼容性。得益于交换机的使用，企业可以混用 100M 和 10M 的设备组网。这样大大的降低了升级的成本。不仅现有的以太网要升级，而且连使用令牌网的用户也跟着转移过来了。&lt;/p&gt;
&lt;p&gt;没过多久，千兆以太网标准化完成。同样提供了向后兼容性。 1000M 100M 和 10M 的设备可以在网络里和谐共存。自此，以太网在局域网领域干掉了所有的竞争对手。&lt;/p&gt;
&lt;p&gt;但是，以太网还有更大的野心，刚掉广域网的竞争对手。他首先干掉了 FDDI。 FDDI 使用光纤介质，提供 100Mbps 的速率。既可以作为局域网，也可以做广域网。而 100Mbps 的光纤以太网的出现把 FDDI 消灭了。如果我在局域网里可以使用以太网，为啥我不可以直接把局域网扩展到更大的范围呢？ 与其使用额外的设备，不如继续使用以太网。如果使用其他协议，就不能和现有的以太网互通了。&lt;/p&gt;
&lt;p&gt;在局域网占据垄断地位的以太网，当他要开发超过100M的通信介质，就把速率低于 以太网的光纤网络一个一个的消灭了。SDH 但是能提供155 Mbit/s 的速度，但是在千兆光纤以太网面前又如何能抵挡。传统的光纤通信格式在以太网面前不断沦陷。&lt;/p&gt;
&lt;p&gt;SONET/SDH 和 ATM 被寄予厚望。毕竟 SONAT 能提供更快的速率。但是在万兆以太网和十万兆以太网的夹击下，市场越来越小。 与此同时，IP 网络的发展也推波助澜。传统上的电信网络，是为了支持“电话” 这一目的，用来跑 IP 包，反而有种杀鸡用牛刀的感觉，成本上无法敌过直接使用以太网作为IP网的承载。当 40G/100G 以太网完成标准化的时候，传统电信网络的木日就到来了。毕竟，对运营商来说，电话越来越少了，IP业务越来越多了。使用更适合承载IP网的技术不是更好的选择吗？ 最后连电话都使用 SIP 网关，运营商改用IP网承载电话业务。&lt;/p&gt;</description>
    </item>
    <item>
      <title>脑洞：可编程网卡</title>
      <link>https://microcai.org/2016/11/21/network-shader.html</link>
      <pubDate>Mon, 21 Nov 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/11/21/network-shader.html</guid>
      <description>&lt;p&gt;很久以前，网卡就只是个物理协议转换装置。各种数据的处理都是靠的 CPU。随着网卡支持的速率的提升，还有人们对效率的追求，网卡开始支持将一些操作给 offload 到网卡上执行。比如checksum的计算。再后来，连 TCP 这样的协议都可以直接交给网卡处理。叫 TCP offload。&lt;/p&gt;
&lt;p&gt;网卡能 offload 的东西越多，高网络负载下的 cpu 使用率就越低。数据处理也就越有效率。
既然连 TCP 都能交给网卡处理了，为何不更进一步实行通用 offload 呢？&lt;/p&gt;
&lt;p&gt;通用 offload 的实现，可以参考显卡的通用可编程渲染管线。搞一个通用网络包处理管线。指定个shader语言，就叫 network shader吧。把 network shader 载入网卡，就可以让网卡执行 network shader 处理收到的数据包。对于太复杂的逻辑，再转给 CPU 上的代码处理，简单的逻辑就可以直接片上处理完成。这对很多 “数据包转发类“ 的引用程序（各种Proxy）来说，可以极大的提升性能。&lt;/p&gt;</description>
    </item>
    <item>
      <title>路由口和交换口</title>
      <link>https://microcai.org/2016/11/20/ports-on-router.html</link>
      <pubDate>Sun, 20 Nov 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/11/20/ports-on-router.html</guid>
      <description>&lt;p&gt;很久以前，我买路由器非常关心路由器有几个口。但是我最终发现，其实路由器都只有2个口。
一个 WAN 口一个LAN口。哪怕是一些双WAN的路由器，其实也只有3个口，2个WAN口一个LAN口而已。&lt;/p&gt;
&lt;p&gt;至于你看到的4个LAN口，那不是口，那只是内置了一个交换机。&lt;/p&gt;
&lt;p&gt;说道这，就得科普一下 路由口和交换口 的区别。&lt;/p&gt;
&lt;p&gt;所谓交换口，就是一个2层可以通的RJ45口。而路由口，才是可以配置 IP 地址的口,路由口才能做三层转发.&lt;/p&gt;
&lt;p&gt;一般路由器只有2个口，一个WAN口，DHCP获取或者PPPOE获取，一个 LAN 口，固定ip，并可以为下面的机器提供 DHCP。 LAN 口通过交换机扩展出多个交换口。&lt;/p&gt;
&lt;p&gt;交换口是不值钱的。一个 8LAN 口的和 4 LAN 口的路由器，成本差距微乎其微额。因为本质上这个路由器只是双口路由器，只是内置的交换机4口还是8口的区别。&lt;/p&gt;
&lt;p&gt;而交换机，这种口这么少的，是不值钱的。不信自己上马云家找找看。几十块钱就能买到8个口的交换机。还是8个千兆口的。8LAN口的通常还只是百兆口。&lt;/p&gt;
&lt;p&gt;路由口才值钱。真的路由器，上有5个口，才真的是贵的很呢。&lt;/p&gt;
&lt;p&gt;在路由器市场，杀出了一个叫 Ubnt 的公司，简直就是杀价神，小米在它眼里简直不知道 low 到哪里去了。&lt;/p&gt;
&lt;p&gt;他最新被众人注意到，是因为推出了一个 3 口路由器 ER-Lite。注意我上面说的路由口和交换口的区别。这个是3个路由口的路由器。还支持千兆线速转发。价钱居然不到一百美金。简直是价格屠夫。&lt;/p&gt;
&lt;p&gt;但是这不是重点，重点是没多久它又推出了一个5口路由器 ERX 。价格 49美刀！
注意是5个路由口哦！ ER-PRO 也有5 个口，但是其实后面3个口是在一个交换机上的，本质是3个路由口。&lt;/p&gt;
&lt;p&gt;哦，为啥比3口的还便宜，因为虽然有5个路由口，但是包转发率下来了。虽然下来了，但是如果发的是大包而不是小包，那跑千兆还是绰绰有余的。只是跑小包就达不到千兆了，也就是所谓的无法线速转发。&lt;/p&gt;
&lt;p&gt;但是家庭使用，在需要速度的地方（NAS，迅雷下载），必定是大包转发。所以，就是个49美元能买到的5个路由口的机器啊！简直是价格屠夫。要知道老 思科 那些百兆的5口路由器二手都不止 49美元呢！虽然能线速百兆，问题是也才百兆而已。&lt;/p&gt;
&lt;p&gt;虽然说有5个口，意味着5个网络，家里一般就一个 wan 一个 lan ，哪里用得到5个？
抛开有的人要双拨，然后不同设备组到不同的网段里不谈，大部分人其实只需要双口路由器的。
这种情况下，他也提供了把任意的口划到一个交换组里的功能。 划到交换组里的口就不能设置 ip地址了，不过可以统一给这个交换组设置一个ip。划到交换组里的口，进行二层包转发的时候，也是会使用独立的交换芯片进行，不占用cpu的资源。&lt;/p&gt;
&lt;p&gt;物理上这是个单芯片的路由器，但是逻辑上，芯片上除了cpu，还集成了5个网卡和一个交换机的。 5个 RJ45 的 phy 接口可以随意的配置为接入交换机或者接入网卡。所以接入交换机后，就不受他的标称包转发速率的影响的，其实也是个线速转发的5口交换芯片。&lt;/p&gt;
&lt;p&gt;不过这个价钱你肯定不会把他当个交换机的，当然是5个网段搞起咯。扩展端口什么的，用个额外的交换机就可以啦！&lt;/p&gt;</description>
    </item>
    <item>
      <title>soho路由器是单臂路由器</title>
      <link>https://microcai.org/2016/11/14/soho-router-is-one-armed-router.html</link>
      <pubDate>Mon, 14 Nov 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/11/14/soho-router-is-one-armed-router.html</guid>
      <description>&lt;p&gt;用 VLAN 划分局域网后，2个局域网之间就不能通信了。如果要让这2个网络能互访，就需要路由器。如果VLAN只是用来做端口隔离，那它本身就毫无意义，买多台独立的口少点的交换机更便宜。VLAN所以那么有用，完全是因为 vlan trunk 端口的存在。使得以太网在交换机上变成了一种隧道。一个二层的隧道。于是只有一个接口的路由器在这种隧道的帮助下能访问被 VLAN 隔离的网络。这种路由器，就是单臂路由器。单臂路由器虽然性能不好，但是能以极低的成本解决网间互联问题。如果网间没有大量的数据交互，单臂路由器就非常合适。当然如果网间有大量数据交换那还是上个3层交换机吧。&lt;/p&gt;
&lt;p&gt;单臂路由器的性能受限的原因是，多个VLAN之间的总数据交换大小为 trunk 端口的 1/2。VLAN1到 VLAN2 的单向数据，就占用 trunk 端口的双向流量。因此总交换容量就只有端口速率的 1/2。对大部分网络来说，这是双向50M（百兆以太网） 或者双向500M(千兆以太网)。&lt;/p&gt;
&lt;p&gt;尽管性能不佳，但是成本低廉，因此应用非常广泛。常见的soho路由器就是单臂路由器和vlan交换机的结合体。&lt;/p&gt;
&lt;p&gt;soho路由器的有线部分，实际上就是个单臂路由器。路由器上的 WAN 口和 LAN口只是分属2个（固定的）vlan。交换芯片有一个隐藏端口直连CPU。这个直连端口就是个 trunk 端口。&lt;/p&gt;
&lt;p&gt;这就是为何百兆路由器并不能跑满百兆宽带。因为单臂路由器就是上下行总和100M， 而且百兆宽带是下行 100M。如果还有上行数据，那么无论如何都无法跑满下行带宽了。&lt;/p&gt;
&lt;p&gt;更换千兆路由器其实有时候并不能解决这个问题，因为&amp;hellip;&lt;/p&gt;
&lt;p&gt;许多廉价的千兆路由器，居然也仅仅是千兆交换芯片。trunk 口直连 CPU 的线路依然是百兆的。因此不是换千兆路由器就行的。你看到的千兆连接只是假象。这样还不如维持原来的路由器，只通过采购额外的千兆交换机来提升内网速度成本来的更低。而且独立的交换机其背板带宽是充足的。而路由器上自带的交换芯片。。通常背板带宽是严重不足的。你能想象内网两台正在对拷数据，居然会影响第三台电脑上外网速度的吗？ 这就是路由器自带的交换芯片背板带宽不足的表现。&lt;/p&gt;</description>
    </item>
    <item>
      <title>Linux多WAN负载均衡原理</title>
      <link>https://microcai.org/2016/11/02/load-balancing.html</link>
      <pubDate>Wed, 02 Nov 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/11/02/load-balancing.html</guid>
      <description>&lt;p&gt;玩了一段时间 EdgeRouter , 对他的负载均衡的可玩性非常着迷。仔细研究后发现，他的实现原理是 iptables 标记数据包，然后对标记的数据包使用使用特定的路由表实现的。&lt;/p&gt;
&lt;p&gt;Linux 默认有一个路由表。这张路由表叫 main 路由表。但是可以用 ip route 命令添加其他路由表。非默认路由表可以用一个数字编号。并且 ip rule fwmark 命令可以设定让被标记的数据使用这个路由表。&lt;/p&gt;
&lt;p&gt;接着，接下来的工作就是，对数据包进行标记。&lt;/p&gt;
&lt;p&gt;标记是基于 connection 的，否则对同一个tcp链接的包用不同的接口出去那可就乱套了。
基于 conntrak 链，对被跟踪的连接打标记。 打标记的时候，可以首先根据目的 ip 打标记，这样就可以避免有特定的ip跟踪的网站出现访问异常。
然后接下来的包，就用 probability 规则打标记. 也就是可能性。 这样有 50% 的新链接被打到 mark 1 上， 50% 的打到 mark 2 上。于是就有一半的流量走 table 1 , 一半的走 table 2&lt;/p&gt;
&lt;p&gt;table 1 使用的 interface 1 做默认网关， table 2 用 interface 2 做默认网关。 于是2个接口上的流量就这样被平均过去了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>家庭wifi覆盖建议</title>
      <link>https://microcai.org/2016/10/24/home-wifi.html</link>
      <pubDate>Mon, 24 Oct 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/10/24/home-wifi.html</guid>
      <description>&lt;p&gt;私以为，目前民用 wifi 路由器市场已经完全走上了邪路。天线越来越大，发射功率越做越高。都敢冒着法律的风险使用大大超过 100mW 的发射功率了。且不论巨大的发射功率可能对人体造成的影响，就从技术上说wifi的特点，为什么wifi不适合大功率发射吧。&lt;/p&gt;
&lt;h1 id=&#34;第一点空口带宽是个共享带宽&#34;&gt;第一点，空口带宽是个共享带宽。&lt;/h1&gt;
&lt;p&gt;共享范围是无线可达的地方，取决于发射功率和损耗。频率越高损耗越大。发射功率越大，意味着越多的设备进入这个大 HUB 来共享空口带宽。不是一个 AP 下带的客户端共享带宽，而是所有无线设备在这个区域内一同共享带宽。一味增加发射功率，违背了网络隔离较大广播域的原则。&lt;/p&gt;
&lt;h1 id=&#34;第二点同频干扰严重&#34;&gt;第二点，同频干扰严重。&lt;/h1&gt;
&lt;p&gt;ISA 频段限制发射功率并不是没有原因的。就是为了限制同频干扰。把同频干扰限制到一个几十米的范围内。在一个小范围内，出现多个同频发射点的概率就小了。增加发射功率，意味着距离很远的2个家庭都会相互干扰对方的网络。大大劣化网络环境。&lt;/p&gt;
&lt;h1 id=&#34;第三点自干扰&#34;&gt;第三点，自干扰&lt;/h1&gt;
&lt;p&gt;发射功率越大，路由器工作的时候自己给自己增加的干扰就越大。其实无线通信最关键的不是接收信号大小，而是信噪比。
如果接受到的信号很强，但是伴随着同样强的噪音信号，一样是无法通信的。&lt;/p&gt;
&lt;p&gt;===&lt;/p&gt;
&lt;p&gt;#那么，解决的办法有没有？ 其实是有的，就是商业环境已经使用很成熟的 多AP 蜂窝式覆盖。&lt;/p&gt;
&lt;p&gt;有人会说，商业使用的，不适合家用吧？&lt;/p&gt;
&lt;p&gt;呵呵，从前也只有商业使用才会用 100M 宽带，现在不是家家户户都用上了吗？ 并没有什么是不合适家用的，只是价钱问题而已。只要价钱低，家庭用户能承受，并没有一定要傲娇到非不去使用，就觉得那样用法是不家庭的。&lt;/p&gt;
&lt;p&gt;其实很多人已经在家里使用多AP（路由器当AP用）覆盖了，但是效果并不好，需要手动选择最近的 AP。这是为啥？&lt;/p&gt;
&lt;p&gt;因为家用的路由器都缺乏一个功能，就是  AP 漫游。&lt;/p&gt;
&lt;p&gt;没有 AP 漫游，即使2个家用路由器设置了一样的 SSID，即使他们都是接的 LAN 口，关了 DHCP 只当 AP 用。设备也不会认为这2个同名的 SSID 有什么关联。并不会主动的切换到信号更强的那个上。除非距离实在远，信号实在差，丢包很严重后，才会依依不舍的断开连接，寻找下一个信号更强的。而且这个寻找也不会是寻找同 SSID 的下一个信号更强的，而是好像这些 AP 都是属于独立的网络一样，按照信号强度排序。很多时候因为其他 ssid 你没有密码，所以恰好就会连上同 SSID 的另一个路由器而已。&lt;/p&gt;
&lt;p&gt;而商用 AP，由于有了一个集中的 “AP 控制器” 简称 AC ， 所以可以控制 AP 实现无缝漫游。而因为是商业产品，所以价格不菲。因为 AP 的大部分功能被 AC 取代，所以又叫瘦 AP， Fit AP。&lt;/p&gt;
&lt;h1 id=&#34;但是经过多年的发展-ac-和-fit-ap-的价格终于降低到家庭用户可以承担的地步啦&#34;&gt;但是经过多年的发展， AC 和 Fit AP 的价格终于降低到家庭用户可以承担的地步啦！！！！！&lt;/h1&gt;
&lt;p&gt;当然这事得感谢 TP-LINK 。&lt;/p&gt;</description>
    </item>
    <item>
      <title>新的路由器</title>
      <link>https://microcai.org/2016/10/18/new-router.html</link>
      <pubDate>Tue, 18 Oct 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/10/18/new-router.html</guid>
      <description>&lt;p&gt;上文说到，我使用无线网桥衔接了2个家庭，组成了一个局域网，共享了宽带。&lt;/p&gt;
&lt;p&gt;但是，局域网和局域网还是太过开放，网桥又是一段不怎么可靠的网线。因此2个局域网最好能隔离开来，隔离广播域，又能通过IP地址直连。
经过研究发现家里宽带还可以多拨。虽然多拨并不叠加带宽，但是可以多获得一个公网ip。有多一个 ip 对 NAT 来说，也是可以极大的提升网络性能的。&lt;/p&gt;
&lt;p&gt;于是找啊找，找发现了一个利器 “ubnt EdgeRouter X”。 不过 350 块钱的价格，但是却提供了思科路由器一样的功能。BGP OSPF RIP 动态路由协议应有尽有。什么？家用用不到动态路由协议？ 呵呵，马上你就知道了，我确实需要它。 提供5个千兆网口，更重要的是，五个独立的网口。也就是在操作系统里是 eth0 eth1 eth2 wth3 eth4 5块网卡。这就可以进行比较高级的玩法了。可以任意组合 N WAN + M LAN ，而不像普通路由器那样，只有一个 WAN 一个 LAN （ 或者少数几个也不过支持双WAN）。 基本上就是一台软路由的玩法了。而且一般软路由都没有5个网卡哦！&lt;/p&gt;
&lt;p&gt;电信自带光猫有2个LAN口，这就是给多拨准备的啊！&lt;/p&gt;
&lt;p&gt;于是作出了这样的规划&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/all-network-struct.svg&#34; width=&#34;100%&#34; /&gt;
&lt;p&gt;ERX路由器和猫之间连了2条网线。直接双拨。&lt;/p&gt;
&lt;p&gt;路由器一个 LAN 连 原来的 wifi 路由器，另一个 LAN 连网桥。&lt;/p&gt;
&lt;p&gt;把原来的路由器，都使用 WAN 口 （注意，是 WAN口哦！） 连到 ERX。无线网桥相当于是网线，所以是姐姐家的路由器 WAN口连到了 ERX 上。&lt;/p&gt;
&lt;p&gt;同时，在两台wifi路由器上关闭 NAT然后打开动态路由 ！！！ 这个很重要！！！ LAN 口的 DHCP 打开， WAN 口使用 DHCP 自动获取。&lt;/p&gt;</description>
    </item>
    <item>
      <title>远程共享宽带</title>
      <link>https://microcai.org/2016/10/11/long-range-wifi.html</link>
      <pubDate>Tue, 11 Oct 2016 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2016/10/11/long-range-wifi.html</guid>
      <description>&lt;p&gt;最近姐姐搬迁到了新家。在我家屋顶能直接看到她的新家。所谓目视可达。我就开始思考，是不是可以无线直连，然后共享网络呢。&lt;/p&gt;
&lt;p&gt;于是淘宝上搜了一圈，最后弄了对山寨 UBNT 无线网桥。然后买了一箱网线，从家里一直沿着电信的光纤一路跟随布线到了楼顶。&lt;/p&gt;
&lt;p&gt;架设好后，姐姐家同理。也是室外放个网桥，然后线走进屋内。&lt;/p&gt;
&lt;p&gt;在屋内，2个网桥都分别和各自的无线路由器连接。&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/ubnt-network-struct.svg&#34; width=&#34;100%&#34;  /&gt;
&lt;p&gt;无线网桥就相当于一段网线。 把2个路由器连接起来变成了一个局域网。&lt;/p&gt;</description>
    </item>
    <item>
      <title>IELTS essay test 1</title>
      <link>https://microcai.org/2015/11/04/essay.html</link>
      <pubDate>Wed, 04 Nov 2015 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2015/11/04/essay.html</guid>
      <description>&lt;p&gt;I couldn’t believe that some people just refused to admire the huge advantage that internet has bought us especially when it was utilized as a source of information. They made the assumption that internet brings more demerits, and too difficult to make it beneficial. Well I will never agree with such vision-less opinion with the following reasons.&lt;/p&gt;
&lt;p&gt;First, the internet reduced the cost of information exchanging and brings us equality. In the old days, when the information can only be carried out on bare metal, the cost to exchange the information is the same as delivering physically real things, you pay both the shipping cost and the materials. Thus, the information only belongs to the rich. But the internet brings us to the information age, where all men and all women, all the rich and all the poor are all equal when it comes to getting the information. The poor are no longer blocked by the entrance price of getting information.&lt;/p&gt;</description>
    </item>
    <item>
      <title>UDP and congestion control</title>
      <link>https://microcai.org/2015/10/06/udp-and-congestion-control.html</link>
      <pubDate>Tue, 06 Oct 2015 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2015/10/06/udp-and-congestion-control.html</guid>
      <description>&lt;p&gt;TCP is good, good for nearly everything. It&amp;rsquo;s a general purpose abstraction for networking applications. But TCP is bad for one thing: it&amp;rsquo;s general. If you have some special need, setsockopt(2) can help you. But really, it dosen&amp;rsquo;t help much.&lt;/p&gt;
&lt;p&gt;What if you have customized need for congestion control?&lt;/p&gt;
&lt;p&gt;The need for different congestion control algorithm is the main reason that we implement
our protocol ontop of UDP.&lt;/p&gt;
&lt;p&gt;I was a little bit shocked that during the 4.2 merge window of Linux, TCP too got a new congestion control algorithm that&amp;rsquo;s a little bit similar to the one I used in my protocol - that is, based on the change rate of RTT, rather than based on a packet lost.&lt;/p&gt;</description>
    </item>
    <item>
      <title>ASIO 腾空出世 （那些年我们追过的网络库.PartII）</title>
      <link>https://microcai.org/2015/09/18/history-of-network-libraries-part-two.html</link>
      <pubDate>Fri, 18 Sep 2015 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2015/09/18/history-of-network-libraries-part-two.html</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;这是上篇 &lt;a href=&#34;http://microcai.org/2015/09/14/history-of-network-libraries-part-one.html&#34;&gt;那些年我们追过的网络库(PartI)&lt;/a&gt; 的后续，&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&#34;asio-腾空出世&#34;&gt;ASIO 腾空出世&lt;/h2&gt;
&lt;p&gt;在地球最大的岛上，另一位少年开始拜读 ACE 的大作。那时候，没有 libuv 没有 libev 更没有 libevent . 有的只是 ACE.
然而这个南方小国的少年没有跟风陷入 ACE 崇拜，他以敏锐的目光察觉到了 ACE 的弊病。
ACE 哪里做的不好？又哪里是值得借鉴的？&lt;/p&gt;
&lt;p&gt;少年在给 c++ 委员会写的一篇上书中说，Proactor 模型乃最优模型。而 Proactor 模型，乃 ACE 提出的 6 个模型之一。根据 IT 界赢者通吃律，一个优秀的网络库，只需要支持 Proactor 模型即可。
支持其他次优模型都是徒劳的。ACE 试图全盘通吃，犯了大忌。&lt;/p&gt;
&lt;p&gt;少年在一次开发者大会的演讲上，再次透露，网络库不宜做成框架，而是要像系统的API那样，作为一个乐高积木。ACE 做成了一个框架，同样不妥。&lt;/p&gt;
&lt;p&gt;你说了那么多 ACE 不好，有本事你弄个好的啊？ 批评者向来都是这么理直气壮。
正如 ACE 的作者实践了 “纸上得来终觉浅 绝知此事要躬行” 一样，这位勇敢的少年也拿出了 ASIO, “实践出真知”，他如是说。&lt;/p&gt;
&lt;p&gt;那还是 SARS 病毒肆虐的年代，几乎没有人注意到，今后颠覆C++的网络世界的 ASIO 悄然出世了。而他的父亲，还只是悉尼的学子。ASIO 并没有显赫的家庭背景，然而英雄不问出处，它注定将有不平凡的一生。&lt;/p&gt;
&lt;p&gt;俗语有云，三岁看老。在 asio 才三岁的时候，它父亲就将 asio 引荐给了 c++ 委员会的老人们。上一次他们这么做的时候，他们接纳了 STL。
ASIO 最终&lt;del&gt;被内定，然后&lt;/del&gt;放入 Boost 锻炼, 经过 Boost 十余的锻炼，ASIO 终于在 2017 年进入了 c++ 标准。&lt;/p&gt;</description>
    </item>
    <item>
      <title>那些年我们追过的网络库(PartI)</title>
      <link>https://microcai.org/2015/09/14/history-of-network-libraries-part-one.html</link>
      <pubDate>Mon, 14 Sep 2015 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2015/09/14/history-of-network-libraries-part-one.html</guid>
      <description>&lt;p&gt;#为什么要用 C++ 编写服务端程序？
如果说答案是性能，那么肯定有人会满不在乎。觉得性能不够的话， 只要加机器就可以了。
然而更少的机器，意味着更低的能耗，更少的硬件投入，更少的人力资源投入去维护机器。总而言之，更低的成本。&lt;/p&gt;
&lt;p&gt;肯定会有人说，C++的开发速度太慢了。然而这并不是绝对的。C++也可以做到非常快速的开发。有句俗语 * “脚本一时爽，重构火葬场” * 说的正是脚本语言开发的项目进入维护阶段后无穷的灾难。而 C++ 经过了几十年的发展, 拥有庞大的工具链. 不管是动态分析还是静态分析都有大量的工具, 能极大的帮助程序员减少错误.
c++得益于精良的设计，严格的检查，越是大型的工程，越是能降低开发成本。&lt;/p&gt;
&lt;p&gt;但这并不意味着C++就不适合小型项目了。小型的项目，也可以快速开发。因为 C++11 开始，已经 &lt;em&gt;感觉像是全新的语言了&lt;/em&gt;，可以完全以脚本的形式去使用，获得接近甚至超越脚本语言的开发速度，同时得益于编译优化，获得不俗的运行时性能。
C++正是鱼和熊掌得兼的语言。&lt;/p&gt;
&lt;p&gt;#为什么要用asio这个库？&lt;/p&gt;
&lt;p&gt;事实上如果使用C++开发服务端程序，你有多得数不清的选择。什么 ACE 啦，libuv 啦，libevent 啦，libev 啦，甚至可以直接使用 epoll/iocp 这样的系统API。
为什么要用 asio 呢？&lt;/p&gt;
&lt;p&gt;##那些年我们用过的网络库&lt;/p&gt;
&lt;p&gt;在计算机史前文明时代, 曾经有个世界难题, 叫 &lt;em&gt;&amp;ldquo;c10k problem&amp;rdquo;&lt;/em&gt;. 这个是继 y2k problem 后的又一个重大攻关项目. 全世界的文艺青年都想拿下解决这个问题的荣誉, 正可谓八仙过海, 各显神通.&lt;/p&gt;
&lt;p&gt;那一年, NPTL 还没有研究出来. 还不能创建成千上万个线程 &lt;br&gt;
那一年, windows 还在蓝屏中挣扎, 无暇顾及网络.&lt;/p&gt;
&lt;p&gt;然而, 曙光还是有的. 异步的出现带给了人以希望. 古老的UNIX早就想到了, 提供了 select() 系统调用供人驱使.
然而问题还是有的, select 只能支持 1024 个文件描述符, windows 上的 select 更是劣质到只能使用64个. 就算通过修改定义强迫接受一万个文件描述符, 也没有解决实际的问题. select  实在是太慢了.&lt;/p&gt;</description>
    </item>
    <item>
      <title>自我意识和物质</title>
      <link>https://microcai.org/2015/08/16/consciousness-and-matter.html</link>
      <pubDate>Sun, 16 Aug 2015 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2015/08/16/consciousness-and-matter.html</guid>
      <description>&lt;p&gt;现代的科学认为物质是不生不灭的. 至少在宇宙的寿命内是这样. 物质的诞生意味着宇宙的开端, 物质的消失意味着宇宙的灭亡.
在宇宙中, 意识并没有特殊的地位. 它不过是地球40亿年进化史的一个副产品.&lt;/p&gt;
&lt;p&gt;真的是这样的吗?&lt;/p&gt;
&lt;p&gt;我始终坚信的一个宇宙真理就是, 万物平等. 伽利略给了运动和静止一个平等的地位. 爱因斯坦给了所有惯性参考系平等的地位. 物理学的发展, 就是不断的消除特例, 不断的将原本不同的东西平等起来.&lt;/p&gt;
&lt;p&gt;我相信, 给予意识和物质一个平等地位的科学时代也即将到来. 而这, 已经露出了苗头.&lt;/p&gt;
&lt;h1 id=&#34;薛定谔的猫&#34;&gt;薛定谔的猫&lt;/h1&gt;
&lt;p&gt;薛定谔的猫, 这一经典实验, 揭示着意识对物质的影响. 意识不仅仅只是物质运动的观察者, 意识也是物质运动的一部分, 决定着物质过去的历史, 决定着现在的状态, 乃至未来的发展.&lt;/p&gt;
&lt;h1 id=&#34;除非进行观测否则一切都不是真实的&#34;&gt;除非进行观测，否则一切都不是真实的。&lt;/h1&gt;
&lt;p&gt;物理世界的存在与否, 取决于是否有人观察它. 没有人观察的世界, 它并不存在.
不能不承认，这听起来很有强烈的主观唯心论的味道。但它其实和我们通常理解的那种哲学理论有一定区别.&lt;/p&gt;
&lt;h1 id=&#34;直到人类开始研究宇宙的历史-宇宙才有了确定的历史&#34;&gt;直到人类开始研究宇宙的历史, 宇宙才有了确定的历史&lt;/h1&gt;
&lt;p&gt;而在人类研究宇宙前, 宇宙的历史是混沌的叠加态. 在人类研究宇宙历史的那一刹那, 整个宇宙的历史就被确定下来了.
这就是量子力学揭示的宇宙之谜.&lt;/p&gt;
&lt;p&gt;然而, 这还未曾被接受过.&lt;/p&gt;</description>
    </item>
    <item>
      <title>GLSL加速 YUV 显示</title>
      <link>https://microcai.org/2015/03/31/optimize_with_glsl.html</link>
      <pubDate>Tue, 31 Mar 2015 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2015/03/31/optimize_with_glsl.html</guid>
      <description>&lt;p&gt;通常来说，视频都是使用 YUV 格式编码的。YUV 最符合人眼的结构，因为人眼对亮度要比对颜色敏感的多。 YUV 将颜色分成一个 亮度信号和2个色差信号。于是就可以使用更多的bit数去编码亮度信号。在同样的每像素比特位数下，YUV 能比 RGB 保留更多的信息。&lt;/p&gt;
&lt;p&gt;But YUV 要在 PC 屏幕上显示，不那么友好。需要转成 RGB 格式。网上一搜一大把，这里就不贴转换公式了。&lt;/p&gt;
&lt;p&gt;将YUV转换为 RGB 时，是像素独立的。每个像素都可以独立转换，因此可以被大规模并行。所以 YUV 最佳的转换地方还是在 GPU 上。不适合在 CPU 上转。&lt;/p&gt;
&lt;p&gt;非常可惜的是， OpenGL 是基于 RGBA 的。在opengl里无法直接使用YUV。&lt;/p&gt;
&lt;p&gt;But，先知已经考虑到了这点，先知给 OpenGL 加了一道通用计算的能力。这道通用计算能力就叫 .. 额.. Shader。（为啥中文译名叫着色器呢？）&lt;/p&gt;
&lt;p&gt;Shader 简单的来说就是一小段跑在 GPU 上的代码。这些代码针对每一个提交的顶点和每一个最终屏幕像素并行执行。
处理顶点数据的就是顶点着色器。处理屏幕像素的就是像素着色器了。&lt;/p&gt;
&lt;p&gt;因此, 将 YUV2RGB 的公式写成一个 shader, 就能实现在 GPU 上并发转格式了.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-GLSL&#34; data-lang=&#34;GLSL&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt; yuv2rgb(&lt;span style=&#34;color:#66d9ef&#34;&gt;in&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt; yuv)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// YUV offset&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// const vec3 offset = vec3(-0.0625, -0.5, -0.5);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt; offset &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt;(&lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0.0625&lt;/span&gt;, &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;, &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0.5&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// RGB coefficients&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt; Rcoeff &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt;( &lt;span style=&#34;color:#ae81ff&#34;&gt;1.164&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;0.000&lt;/span&gt;,  &lt;span style=&#34;color:#ae81ff&#34;&gt;1.596&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt; Gcoeff &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt;( &lt;span style=&#34;color:#ae81ff&#34;&gt;1.164&lt;/span&gt;, &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0.391&lt;/span&gt;, &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0.813&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt; Bcoeff &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt;( &lt;span style=&#34;color:#ae81ff&#34;&gt;1.164&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;2.018&lt;/span&gt;,  &lt;span style=&#34;color:#ae81ff&#34;&gt;0.000&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;vec3&lt;/span&gt; rgb;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	yuv &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; clamp(yuv, &lt;span style=&#34;color:#ae81ff&#34;&gt;0.0&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;1.0&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	yuv &lt;span style=&#34;color:#f92672&#34;&gt;+=&lt;/span&gt; offset;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	rgb.r &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; dot(yuv, Rcoeff);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	rgb.g &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; dot(yuv, Gcoeff);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	rgb.b &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; dot(yuv, Bcoeff);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; rgb;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;输入为一个 vec3 的向量, 返回 vec3 向量. 这个转换对每个像素并发的执行.&lt;/p&gt;</description>
    </item>
    <item>
      <title>ubuntu 太反人类了</title>
      <link>https://microcai.org/2014/11/11/fuck-ubuntu.html</link>
      <pubDate>Tue, 11 Nov 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/11/11/fuck-ubuntu.html</guid>
      <description>&lt;p&gt;ubuntu 这个烂东西, 我本来不打算吐槽的, 反正烂东西我不触碰就是了.&lt;/p&gt;
&lt;p&gt;但是啊, 烂东西呢, 你不过去招惹它, 它还是会过来招惹你, 不管你愿意还是不愿意.&lt;/p&gt;
&lt;p&gt;ubuntu 为啥烂 ? 怎么招惹我了?&lt;/p&gt;
&lt;p&gt;因为咱用了 travis-ci . travis-ci 是个好东西啊, 每次你 git push , 它就默默的帮你编译一遍代码. 哪个 commit 没编译过, 一目了然.&lt;/p&gt;
&lt;p&gt;问题在于, travis-ci 用的是 ubuntu , 而且更糟糕的是用的 ubuntu 12.04 &amp;hellip; 太老了.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;首先遇到的第一个问题, 就是包名好乱. 我要用一个库的时候, 我不知道要安装哪个库! 我不知道 ubuntu 打包的时候到底用了啥名字.
我不能因为用了这个名字的库,而推定 ubuntu 一定打包成这个名字. 必须上  ubuntu 的网站查询! 其实这个问题我老早就说过了. 诶.&lt;/p&gt;
&lt;p&gt;包名混乱, 用户不得不多上网站搜索, 网站流量就上来了, 就看起来 &amp;ldquo;活跃&amp;rdquo; 了. 排名就高了&amp;hellip; 真是个好生意.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;第二个问题, 是软件太旧了. 真的太久了. 好不容易找好了正确的包名, 开开心心的在 .travis.yaml 文件里添加了 apt-get 命令 &amp;hellip;
结果软件实在是太旧了! 这些软件当年刚进入 ubuntu 仓库的时候就已经是旧了, 但还勉强够用. 但是过了这么多年, 等 ubuntu 自己都旧了的时候,
这些软件就是古董到不能再古董了.&lt;/p&gt;</description>
    </item>
    <item>
      <title>也说 jitter</title>
      <link>https://microcai.org/2014/10/16/jitters.html</link>
      <pubDate>Thu, 16 Oct 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/10/16/jitters.html</guid>
      <description>&lt;p&gt;搞数字音频的，经常会提到 jitter。 什么是 jitter ？&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/jitter1.png&#34; &gt;
&lt;p&gt;jitter 就是时钟的随机抖动。这个抖动啊，来自量子世界，是无法消除的，否则海森堡大人要从棺材里跳出来了。
jitter 只能减少，不能削除。&lt;/p&gt;
&lt;p&gt;那么 jitter 对音频有啥影响呢？&lt;/p&gt;
&lt;img src=&#34;https://microcai.org/images/jitter2.png&#34; width=&#34;70%&#34;&gt;
&lt;p&gt;jitter 主要影响就是，经过 DAC 重建模拟信号的时候，时钟的不稳定导致重建信号偏离原来的位置。结果上看就是波形不再符合原来的PCM编码的描述了。
这个偏差引入了失真，但是数据的准确性并没有被破坏。&lt;/p&gt;
&lt;p&gt;那么 jitter 既然无法消除， 总有个量的吧？ 小于某个量后，人耳就无法察觉了，对吧？
是的。一般认为，jitter 小于 200皮秒后人耳即无法感知了。&lt;/p&gt;
&lt;p&gt;一般数字电路的 jitter 有多大？ 数字电路通常使用石英晶振产生时钟，石英晶振的 jitter 是很小的。石英晶振 jitter 可以做到小于 1ps （皮秒）。
所以 jitter 影响音质的说法基本上是无稽之谈。&lt;/p&gt;
&lt;p&gt;这个时候，玄学大师会出来说，低 jitter 的那是本地时钟。如果使用的不是本地时钟，比如使用 SPDIF 传输音频，时钟信号是包含在信号里的。
解码器要从被光电转换线路劣化（或者使用同轴传输，信号会被外界电磁干扰劣化）的信号里重建数据和时钟。这个时钟就很难保证低jitter。&lt;/p&gt;
&lt;p&gt;是的确实如此。外界干扰确实让同轴或者光纤传来的信号 jitter 大大增加。有网友以示波器观察，发现波形已经被严重歪曲。数字信号以电压判断， 接收到的波形因为已经扭曲，波形的上升坡度各不相同。所以上升到指定电压以被判定为 1 的时间就各不相同。 哪怕原始波形以精确的时间开始上升 。。。。
如此以来，jitter确实很大。&lt;/p&gt;
&lt;p&gt;但是，哪怕同轴上单个 bit 的 jitter 高达 1000ps (其实已经很低了，但是足以引起听感不适)， 提取出来的信号和时钟的jitter依然能做到非常低。
这是为何呢？ 因为重建信号使用了 PLL （锁相环） 机制。&lt;/p&gt;
&lt;p&gt;spdif 信号并不能直接 DAC 解码，而是需要提取出时钟信号和音频数据。spdif 信号是一帧一帧传播的。而不是一个采样点一个采样点传播的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>更高采样率，更低成本</title>
      <link>https://microcai.org/2014/10/11/higher-sample-rate-cheaper-device.html</link>
      <pubDate>Sat, 11 Oct 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/10/11/higher-sample-rate-cheaper-device.html</guid>
      <description>&lt;p&gt;在继续本文之前，容我提出一个摩尔定律的推论： 离摩尔定律越近，发展越快，成本越低；反之，离摩尔定律越远，发展就越缓慢，成本也难以下降。&lt;/p&gt;
&lt;p&gt;[待续]&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;=== 2023 年 12月 21 日填坑 ===&lt;/p&gt;
&lt;p&gt;没想到，当年的一篇文章，我居然没完成。挖坑了这么久。&lt;/p&gt;
&lt;p&gt;这次来回填。&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;在玄学HIFI领域，是反摩尔定律的。&lt;/p&gt;
&lt;p&gt;数字音频，是个跨领域的行业。一方面，他是数字化的。一只脚在摩尔定律统治的领域。 另一只脚则是在一个传统的音像行业。&lt;/p&gt;
&lt;p&gt;快速发展的摩尔领域，就容易导致劈叉越来越严重。然后就扯到蛋了。&lt;/p&gt;
&lt;p&gt;一方面，摩尔统治下的半导体，性能指数级提升。ADC芯片能实现的采样率，很快就从 44.1khz 到了 25Ghz 以上。&lt;/p&gt;
&lt;p&gt;另一方面，传统的音像行业坚守 44.1khz 的本心不动摇。传统行业的坚守，也让 ADC 芯片的从业者，分化为了两个阵营。一个是摩尔阵营，一个是音响阵营。&lt;/p&gt;
&lt;p&gt;摩尔阵营的 ADC，每 18个月，价格降低一半。或者相同的价格能买到翻倍的采样率。&lt;/p&gt;
&lt;p&gt;音响阵营，实行的是稳定供货策略。一个 44.1khz 的 ADC, 他打着保票说，这个芯片能供货30年以上，而且绝对不乱涨价。&lt;/p&gt;
&lt;p&gt;二者之间还有一个心照不宣的秘密：摩尔阵营的ADC绝对不染指音响市场。&lt;/p&gt;
&lt;p&gt;于是市面上，你能花一两块钱的价格买到的芯片，里面内赠的ADC能达到100khz采样速度，还能采集十几个通道。&lt;/p&gt;
&lt;p&gt;但是如果你要采集的是区区20khz 带宽的信号，就必须买专门的44.1kz 采样率的ADC。这个ADC，价格从几十元到上万元不等。&lt;/p&gt;
&lt;p&gt;在  44.1khz 成为标准的年代。1.44MB/s 的码率异常惊人。耗尽一台个人电脑的全部存储空间，无法记录一秒的声音。&lt;/p&gt;
&lt;p&gt;但是，时间未过几年。个人电脑单是RAM的容量，都能放下数张CD光盘了。 就别提硬盘的容量了。更是指数级提升。&lt;/p&gt;
&lt;p&gt;按理说，音响制作领域，完全可以使用更高的采样率，更大的码率制作音频。&lt;/p&gt;
&lt;p&gt;但是，44.1khz 依旧统治世界。从 VCD 到 DVD ， 再到 BD。
整个媒体文件里，音频信息所占用的数据量比例，不断的下降。到 BD 时代，整个 25GB 容量的光盘里，音频信息只有数百MB。与 VCD 时代相比，只有略微的提升。这略微的提升，还是因为 BD 使用了更多的声道，而不是更高的采样率。&lt;/p&gt;
&lt;p&gt;声音的原始数据量，已经从巨量变成了无足轻重。 无损压缩的音频，突然成了主流。&lt;/p&gt;
&lt;p&gt;摩尔定律界的人，已经嫌弃音频的数据量太小了。填不满巨大的存储空间。不得不劝大家不要压缩声音了。再压缩，硬盘厂都要倒闭了。&lt;/p&gt;
&lt;p&gt;声音，从一开始的大山，变成了一粒尘埃。&lt;/p&gt;
&lt;p&gt;但是。音响界的人不这么看。声音他必须得是大山。我不允许摩尔定律碾压声音。不允许！&lt;/p&gt;
&lt;p&gt;其实，主动远离摩尔定律，何止是 HIFI 行业。还有单片机行业。&lt;/p&gt;</description>
    </item>
    <item>
      <title>超线程, 优先级和调度策略</title>
      <link>https://microcai.org/2014/08/17/smthyperthreading-nice-and-scheduling.html</link>
      <pubDate>Sun, 17 Aug 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/08/17/smthyperthreading-nice-and-scheduling.html</guid>
      <description>&lt;p&gt;这是 ck 的一篇文章，原始链接在此 (SMT/Hyperthreading, nice and scheduling policies)[http://ck-hack.blogspot.com/2014/08/smthyperthreading-nice-and-scheduling.html]&lt;/p&gt;</description>
    </item>
    <item>
      <title>使用自己硬件的时候写的两个补丁</title>
      <link>https://microcai.org/2014/08/09/two-kernel-patch-for-my-pc.html</link>
      <pubDate>Sat, 09 Aug 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/08/09/two-kernel-patch-for-my-pc.html</guid>
      <description>&lt;h1 id=&#34;键盘问题&#34;&gt;键盘问题&lt;/h1&gt;
&lt;p&gt;去年买了一个机械键盘。不过一直有一个困扰我的问题，就是键盘插入 USB 口后，会等待 10s 左右的时间，然后才识别。查看 dmesg 输出会看到有什么 Timeout 的。
后来发现是硬件 bug。而这种硬件 bug 是可以被内核 work-arround 的。 具体的来说就是，一个 USB-HID 插入的时候，内核会询问设备的一些特性，比如说是否支持多点触控之类的。
但是我这块键盘并不会不报告，导致内核等了大概 10s 没收到报告，于是就当你不支持咯。才继续下去。当然，除了这个该死的硬件闭口不谈外，没啥别的 bug。 所以 10秒后，键盘还是能正常使用。&lt;/p&gt;
&lt;p&gt;那么解决办法就很简单了，把这个键盘的设备 ID 添加到一个 缺陷列表， 列表文件在 drivers/hid/usbhid/hid-quirks.c 。
当然，遵循内核的设计风格，不能直接把设备 ID 这种 16 进制的数字填进去，所以在 drivers/hid/hid-ids.h 这里添加了宏定义。
补丁如下&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;  From 7af026610fe6a41426f53f3a4ea41e3aa1ee780f Mon Sep 17 00:00:00 2001
  From: microcai &amp;lt;microcaicai@gmail.com&amp;gt;
  Date: Sun, 13 Jul 2014 15:41:14 +0800
  Subject: [PATCH] HID: usbhid: add quirks for 0x04d9:0xa096 keyborad device

  I am using a USB keyborad that give me
  &amp;#34;usb_submit_urb(ctrl) failed: -1&amp;#34; error when I plugin it.
  and I need to wait for 10s for this device to be ready.

  by adding this quirks, the usb keyborad is usable right after plugin

  Signed-off-by: Wangzhao Cai &amp;lt;microcaicai@gmail.com&amp;gt;
  ---
  drivers/hid/hid-ids.h           | 1 +
  drivers/hid/usbhid/hid-quirks.c | 1 +
  2 files changed, 2 insertions(+)

  diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
  index 48b66bb..9683f6c 100644
  --- a/drivers/hid/hid-ids.h
  +++ b/drivers/hid/hid-ids.h
  @@ -479,6 +479,7 @@
  #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A070    0xa070
  #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A072    0xa072
  #define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A081    0xa081
  +#define USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD_A096 0xa096
  
  #define USB_VENDOR_ID_IMATION          0x0718
  #define USB_DEVICE_ID_DISC_STAKKA      0xd000
  diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
  index 31e6727..e2e8b7c 100644
  --- a/drivers/hid/usbhid/hid-quirks.c
  +++ b/drivers/hid/usbhid/hid-quirks.c
  @@ -124,6 +124,7 @@ static const struct hid_blacklist {
	  { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_HD, HID_QUIRK_NO_INIT_REPORTS },
	  { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_QUAD_HD, HID_QUIRK_NO_INIT_REPORTS },
	  { USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP_V103, HID_QUIRK_NO_INIT_REPORTS },
  +       { USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD_A096, HID_QUIRK_NO_INIT_INPUT_REPORTS | HID_QUIRK_HIDINPUT_FORCE },
  
	  { 0, 0 }
  };
  -- 
  2.0.4
&lt;/code&gt;&lt;/pre&gt;&lt;h1 id=&#34;看门狗设备问题&#34;&gt;看门狗设备问题&lt;/h1&gt;
&lt;p&gt;在 奶茶东 6/18 活动的时候，杀了一块 Z97 主板和 i7 一块回来。当然，顺便低价处理掉了原来的 P8P67 主板和 E3-1230 CPU。&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 10.4 发布</title>
      <link>https://microcai.org/2014/06/06/avbot-10.4.html</link>
      <pubDate>Fri, 06 Jun 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/06/06/avbot-10.4.html</guid>
      <description>&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 不知不觉都已经经历一年有余的开发啦。 10.4 版本应该是一个里程碑式稳定版本。呵呵。 更新还是挺多的。&lt;/p&gt;
&lt;p&gt;avbot 的验证码识别功能详情请参考项目 &lt;a href=&#34;http://wiki.avplayer.org/deCAPTCHA&#34;&gt;wiki&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&#34;下面是-changelog&#34;&gt;下面是 Changelog&lt;/h2&gt;
&lt;p&gt;10.4
* 更新了内置的 gloox 库。&lt;/p&gt;
&lt;p&gt;10.3
* 添加了 systemd 支持&lt;/p&gt;
&lt;p&gt;10.2
* 添加了 libZMQ 支持.
* windows 上改进型的 GUI 处理&lt;/p&gt;
&lt;p&gt;10.1
* 使用 stackfull 协程重写 xmpp 逻辑。
* 移除 boost.log 依赖，我能说 boost.log 是个垃圾库么？&lt;/p&gt;
&lt;p&gt;10.0
* 新增 python 脚本支持。
* lua 功能在 win32 平台利用 延迟加载DLL特性，只要存在 lua51.dll 即可开启功能，不存在即关闭。无需作为编译选项。
* qq密码支持非明文，提高安全性&lt;/p&gt;
&lt;p&gt;9.3
* 新增了一个 avextension.dll 的扩展支持，通过加载该扩展DLL实现功能扩展&lt;/p&gt;
&lt;p&gt;9.2
* 添加了 纯真 IP 数据库支持。在聊天中提到的 ip 地址都会响应地理位置.
9.0
* libwebqq is now submoduled. that means, libwebqq is an seperated project now.
* .qqbot mail end 并不能终止邮件记录，再次发出该命令将导致目前为止的记录被再次发送. 因而多次执行 .qqbot mail to将导致意外的信息泄漏。修正次错误&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 里的回调</title>
      <link>https://microcai.org/2014/05/25/callbacks-on-avbot.html</link>
      <pubDate>Sun, 25 May 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/05/25/callbacks-on-avbot.html</guid>
      <description>&lt;p&gt;asio 这样的库，每次发起一个操作，就带一个回调．回调告诉你，神马时候操作完成了，完成的咋样．&lt;/p&gt;
&lt;p&gt;在所有被主动调用的接口处，　avbot 基本上都遵循了 asio 的这一设计准则：提供回调完成事件通知．&lt;/p&gt;
&lt;p&gt;但是，还有另一种回调：这个回调并不是因为你主动调用了某个接口，而是因为，这是框架的一部分．&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;你不用调用框架，框架会来调用你．&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;在被框架调用的地方，如果阻塞了，势必会导致框架内部的执行流被整个阻塞．比如说，如果设定一个
&amp;ldquo;验证码回调&amp;rdquo;，框架登录QQ发现需要验证码的时候就调用．那么，执行解验证码这个操作如果费时（这
肯定费时啊，等待用户从控制台输入嘛）会导致整个avbot的内部循环被阻塞.　&lt;/p&gt;
&lt;p&gt;这明显不是我想要的结果．&lt;/p&gt;
&lt;p&gt;这也是因此我极力避免框架式设计．　但是，框架式设计有时候又是无可奈何的最简单的做法．&lt;/p&gt;
&lt;p&gt;&lt;em&gt;那么，为何不让我们的回调接受一个框架传来的　Handler ?&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;是的！ 这样框架就无需要求回调一定是非阻塞的了！&lt;/p&gt;</description>
    </item>
    <item>
      <title>读博客园的创业历史</title>
      <link>https://microcai.org/2014/05/12/about-startup.html</link>
      <pubDate>Mon, 12 May 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/05/12/about-startup.html</guid>
      <description>&lt;p&gt;前些日子，看到微博上传说，博客园的真爱是阿里云。说他们在阿里云平台上走了一次又一次的弯路，当了一次又一次的小白。但是，阿里虐他千百遍，他待阿里如初恋。&lt;/p&gt;
&lt;p&gt;顿时觉得有趣，于是去看了博客园解决云计算之路上的一个又一个坑。&lt;/p&gt;
&lt;p&gt;开始是抱着围观群众看热闹的心态去看的，看来他们一年多踩的无数个坑，每次踩坑还都去研究源码去找解决办法，顿时觉得，这个团队其实是一个脚踏实地的人在领导。
没有那种浮躁的氛围，肯耐心去做事情。于是去看站长 dudu 的日志。
发现第一篇博客是 04 年发出的。 原来博客园都已经坚持了十年了！&lt;/p&gt;
&lt;p&gt;十年前，博客园还只是 dudu 的一个小玩具。但是他总是安心的更新技术，每月都有数篇博文。这种坚持实在难得！
4年后， 也就是  08 年，dudu 开始创业，将博客园从个人站转向公司。&lt;/p&gt;
&lt;p&gt;在创业前，以一己之力维护了一个站点4年。4年不间断的更新程序。不间断的写博文记录。这种坚持，实在是佩服！&lt;/p&gt;
&lt;p&gt;开始创业一年多后，他们才注册了公司。&lt;/p&gt;
&lt;p&gt;是的，如果没有必要，不要成立公司。公司一经成立，就开始为政府烧钱，晚成立公司一点，就可以省下大笔开支。&lt;/p&gt;
&lt;p&gt;创业，维持小而精的团队，如无必要，不需要成立公司。在盈利之前都可以无公司组织。公司这种东西，可以等开始盈利的时候去注册。&lt;/p&gt;</description>
    </item>
    <item>
      <title>纯真数据库下载或自动更新实现</title>
      <link>https://microcai.org/2014/05/11/qqwry_dat_download.html</link>
      <pubDate>Sun, 11 May 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/05/11/qqwry_dat_download.html</guid>
      <description>&lt;p&gt;用过珊瑚虫的童鞋都知道, 有个叫 &amp;ldquo;纯真数据库&amp;rdquo; 的东西, 可以查询 ip 地址对应的物理地址.&lt;/p&gt;
&lt;p&gt;纯真数据库是有个名为 QQWry,DAT 的二进制文件, 可以通过纯真数据库自己提供的查询程序进行更新.&lt;/p&gt;
&lt;p&gt;有关该数据库格式和解析的内容, 本帖子暂时不讲, 有机会的话, 偶会另行开个新帖子讲讲.&lt;/p&gt;
&lt;p&gt;这里讲的是, 不通过官方的查询程序, 如何获取到这个数据库. 通过对官方程序进行抓包, 得出下载此数据库, 主要需要下载&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://update.cz88.net/ip/copywrite.rar&#34;&gt;http://update.cz88.net/ip/copywrite.rar&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;和&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://update.cz88.net/ip/qqwry.rar&#34;&gt;http://update.cz88.net/ip/qqwry.rar&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;两个文件.&lt;/p&gt;
&lt;p&gt;但是很明显,这两个压根不是 rar 文件呀! 别被扩展名迷惑了.&lt;/p&gt;
&lt;p&gt;因为要下载两个文件, 所以得出一个很明显的结论, ** 第二个文件需要用到第一个文件里的信息才能正确解开, 获得 qqwry.dat 文件. **&lt;/p&gt;
&lt;p&gt;那么,  copywrite.rar 里到底有神马东西呢?&lt;/p&gt;
&lt;p&gt;我们来打开它&lt;/p&gt;
&lt;p&gt;ghex copywrite.rar&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;copywrite.png&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/copywrite_rar.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;好吧,老实说, 根本看不明白嘛!&lt;/p&gt;
&lt;p&gt;那咋办？&lt;/p&gt;
&lt;p&gt;祭出　IDA !!!!!!&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;华丽的风格线，　其实网上已经有人说了，　这个　copywrite.rar 就是如下一个结构体．&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;struct&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;copywritetag&lt;/span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; sign;&lt;span style=&#34;color:#75715e&#34;&gt;// &amp;#34;CZIP&amp;#34;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; version;&lt;span style=&#34;color:#75715e&#34;&gt;//一个和日期有关的值
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; unknown1;&lt;span style=&#34;color:#75715e&#34;&gt;// 0x01
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; size;&lt;span style=&#34;color:#75715e&#34;&gt;// qqwry.rar大小
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; unknown2;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; key;&lt;span style=&#34;color:#75715e&#34;&gt;// 解密qqwry.rar前0x200字节所需密钥
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt; text[&lt;span style=&#34;color:#ae81ff&#34;&gt;128&lt;/span&gt;];&lt;span style=&#34;color:#75715e&#34;&gt;//提供商
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt; link[&lt;span style=&#34;color:#ae81ff&#34;&gt;128&lt;/span&gt;];&lt;span style=&#34;color:#75715e&#34;&gt;//网址
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这里，最重要的就是　key 这个整数拉！　接下来要在解码　qqwry.rar 里用到&lt;/p&gt;</description>
    </item>
    <item>
      <title>聊聊  type  erasure</title>
      <link>https://microcai.org/2014/04/21/type-erasure.html</link>
      <pubDate>Mon, 21 Apr 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/04/21/type-erasure.html</guid>
      <description>&lt;h1 id=&#34;什么是类型橡皮擦&#34;&gt;什么是类型橡皮擦?&lt;/h1&gt;
&lt;p&gt;type eraer是什么？ 为什么这么有用？ 到底它是如何帮助你构建灵活强大的软件的？&lt;/p&gt;
&lt;p&gt;我们知道 C＋＋ 是一个强类型的语言。 不同类型之间有天壤之别 ，不能任意转化——函数有签名，只有符合类型检查才能调用。
类型稍微有点不匹配，那带来的是一堆堆编译错误。
然后很多时候，我们会想，C＋＋的类型能不要那么强就好了！比如说设计一个回调函数 ，这回调函数非得是那个类型的才能使用，多不方便。
为了方便用户，为了能适应变化，我们将不得不使用 void*  参数，然后不停地进行强制类型转换。&lt;/p&gt;
&lt;p&gt;如果 &amp;hellip;&amp;hellip;&lt;/p&gt;
&lt;p&gt;如果能把类型变弱点就好了!&lt;/p&gt;
&lt;p&gt;type erasure 技术应运而生。
其实我们常用的 std::function / boost::function 就是一种  type erasure。
std::function 在一定程度上，抹去了函数的类型。不论来的类型是函数对象，还是函数指针，它统统接受，统统能赋值给它。要知道，函数对象可是有无穷多种类型。&lt;/p&gt;
&lt;h1 id=&#34;弱类型-和模板啥区别&#34;&gt;弱类型？ 和模板啥区别？&lt;/h1&gt;
&lt;p&gt;模板靠编译期自动生成一个类型兼容的函数来做到弱类型，而  type erasure则能实现在运行期弱类型。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Callback&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; somefunc( &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;  somearg, Callback  callback); 
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个是弱类型了吧，但是是靠编译期实现的。如果有100 个类型的回调，就会生成 100 份代码，去适应 100 个类型的回调函数。
但是如果是这样的代码&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;somefunc&lt;/span&gt;( &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; somearg, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;function&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; callback); 
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个也是弱类型吧，但是，不论有多少回调类型，一份代码足矣。
也就是说， type erasure 能弥补模板运行期弱类型能力不足的问题。&lt;/p&gt;
&lt;p&gt;而有时候，你不得不使用 type erasure。
比如说，你需要保持一个容器，里面全是回调函数。
那么模板就无能为力了。因为创建一个容器的时候，已经要把所有的元素的类型都固定为一个了。
这个时候你必须借助 type erasure&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;vector&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;function&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;()&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&amp;gt;&lt;/span&gt; function_container;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;有的人会说，用  void*  不也能实现么？&lt;/p&gt;</description>
    </item>
    <item>
      <title>it is hopeless in china</title>
      <link>https://microcai.org/2014/03/05/hatechina.html</link>
      <pubDate>Wed, 05 Mar 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/03/05/hatechina.html</guid>
      <description>&lt;p&gt;I just Hate CHINA !&lt;/p&gt;</description>
    </item>
    <item>
      <title>折腾了一下GPG和智能卡</title>
      <link>https://microcai.org/2014/02/15/smartcard.html</link>
      <pubDate>Sat, 15 Feb 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/02/15/smartcard.html</guid>
      <description>&lt;p&gt;GPG支持使用智能卡设备存储密钥。
使用文件系统来携带密钥（ 不管是存到 家目录里还是放到U盘里携带）的弊端有很多&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 文件泄漏密钥即泄漏
2. 不能保证密钥的物理唯一性
3. 文件可以被拷贝，文件可以被任意读取
4. 无法知道文件是否被拷贝，不能发觉
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而使用智能卡设备，好处很多&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 密钥具有物理唯一性，一旦生成即无法读取，即无法制作拷贝
2. 密钥可以由卡上的CPU生成，更能保证物理唯一性
3. 智能卡可以随身携带，方便使用不同的电脑
4. 卡遗失即密钥遗失
5. 多次尝试破解会导致智能卡自我销毁，保证密钥的安全，所以遗失的卡也不会泄漏密钥
6. 加解密操作由智能卡硬件完成，即便授权应用程序也无法获取KEY。就别说木马了。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么， gpg 支持哪些硬件呢？&lt;/p&gt;
&lt;p&gt;gpg 支持 CCID 标准兼容的 USB 读卡器。市面上的智能卡读卡器基本上都基于这个接口。
但是，智能卡有很多种，什么门卡啊，电话卡啊，种类很多， gpg 需要的是一个 &amp;ldquo;OpenPGP Card&amp;rdquo; 标准兼容的智能卡。
这种智能卡目前在国内没有购买渠道。&lt;/p&gt;
&lt;p&gt;所幸的是，gpg通过 gnupg-pkcs11-scd 兼容支持了 PKI 设备。
所谓 PKI 设备就是使用 PKCS#11 接口进行访问的物理加解密设备，比如电子狗，U盾。&lt;/p&gt;
&lt;p&gt;那么，我需要的是一个（国内能购买到的）具备 RSA 或者 DSA 加密运算能力的 PKI 设备，同时能在 Linux 下使用。
能在 Linux 下使用，要么是使用标准的 PC/SD 接口，要么是提供了 Linux 下的驱动（PKCS#11 接口允许厂商提供一个 .so 作为驱动访问硬件。应用程序只要使用 PKCS#11 的接口即可。）&lt;/p&gt;</description>
    </item>
    <item>
      <title>折腾了一下 PC HIFI</title>
      <link>https://microcai.org/2013/12/22/hifi.html</link>
      <pubDate>Sun, 22 Dec 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/12/22/hifi.html</guid>
      <description>&lt;p&gt;最近家里闲置了一对老音箱。很大很重的老音箱。年纪有个十几年了吧。但是以前是很贵的东西。虽然现在音箱很便宜（但是便宜了，音质差了呀），但是我没舍得扔掉。在我眼里古董音箱很值钱！&lt;/p&gt;
&lt;p&gt;于是我想个办法想废物利用。音箱有了，缺一个功放。&lt;/p&gt;
&lt;p&gt;我第一个找到的功放，是基于 TD2024 芯片的数字功放。主要是图个便宜，不到 50 块钱就能有一个。
至于什么是数字功放，我恶补了一下功放方面的知识。&lt;/p&gt;
&lt;p&gt;功放分 A 类 B 类 AB 类和 D 类功放。 D 类也就是数字功放。A类功放，让功放管始终工作在线性放大区。就算输入信号是 0, 功放管也在工作。
功耗大，效率低。效率只有  20% 。 大量的电能被白白消耗。&lt;/p&gt;
&lt;p&gt;B 类功放就节能多了。 B 类功放需要2个对管（一个 PNP 一个 NPN），分别放大信号的正半周和负半周。当输入信号处于正半周的时候，放大正半周的功放管工作；当输入信号处于负半周的时候，放大负半周的功放管工作。没有输入信号的时候，两个功放管都不工作。效率不错，能提高到最高 75%。&lt;/p&gt;
&lt;p&gt;但是 B 类功放有个致命缺点： 交越失真。因为晶体管只有高于大约 0.7v 电压的时候才导通进入放大状态。这样，当输入信号处于  正负0.7v内 的状态时，是不会被放大的。而通常这个时候正是处于信号正半周向负半周交越的时候（或者反过来）。于是出现交越失真。
解决办法就是设定一个偏置电流。让功放管的静态工作点（就是输入信号为 0 的时候的工作点）移到线性区域的起始点。这样就形成 AB 类功放了。&lt;/p&gt;
&lt;p&gt;B类功放的2个对管要严格匹配。需要从大量的管子中筛选出参数最接近的。&lt;/p&gt;
&lt;p&gt;不管是 A 类还是 B 类功放，都是利用功放管（通常是晶体管，要有的是用的电子管） 工作在线性区域的时候对电流的放大作用完成信号放大的。都要求功放管有较高的线性度。&lt;/p&gt;
&lt;p&gt;D类功放和前面介绍的都不一样，D类功放对功放管的线性度没要求。因为 D 类功放让功放管工作在  开关 状态。&lt;/p&gt;
&lt;p&gt;D类功放，首先对输入信号进行采样，生成 PWM  ( pulse width modulation, 脉宽调制 ) 信号。信号幅度高的地方，所调制生成的 PWM 信号占空比也高。PWM 信号的频率在  300khz 以上。接着，调制后的 PWM 信号用来控制开关管，输出大电流的 PWM 信号（通过直接调制电源得到）。高频率高电压的 PWM 信号经过一个滤波器，过滤掉  20khz 以上的信号，即可还原出原始的音频信号。&lt;/p&gt;</description>
    </item>
    <item>
      <title>对未来编译器的意淫</title>
      <link>https://microcai.org/2013/09/15/future-compiler.html</link>
      <pubDate>Sun, 15 Sep 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/09/15/future-compiler.html</guid>
      <description>&lt;p&gt;典型的 C++ 编译过程分 &amp;ldquo;预处理&amp;rdquo; &amp;ldquo;编译&amp;rdquo; &amp;ldquo;链接&amp;rdquo;&lt;/p&gt;
&lt;p&gt;编译, 是最耗时的环节, 编译需要编译器解析 C++ 语法, 构建 AST (抽象语法树), 解析完成后, C++ 的重任才刚刚开始. 对于 C 来说, C 解析成语法树后可以立即开始生成目标代码. 但是 C++ 不能. 最耗时的步骤才刚刚开始. C++ 要在 AST 上执行 模板展开, 重载判决. 特别是 模板展开, 这可是一次图灵完全的展开啊! 在展开的过程中, 顺便就以图灵完全的模式执行了一次模板代码. 模板展开失败不是错误, 编译器需要找到另外的模板重载重新展开.&lt;/p&gt;
&lt;p&gt;终于全部任务执行完毕后, 生成一个中间的表示. 接着开始进行第一阶段优化, 这一阶段的优化, 死代码消除, 内联展开. 这很重要, 模板代码就是在这一阶段被内联进去, 以至于和手写一样高效. 死代码消除使得为可读性考虑写的代码, 并不会真正生成目标代码, 编译器知道这是无用, 删了. 完成第一阶段优化后, 转化为目标代码. 转换完成后执行第二次优化. 这次优化是在机器指令层面进行的. 优化的地方有, 向量化啦, 指令重排序啦.&lt;/p&gt;
&lt;p&gt;最终生成优化的目标代码, 然后写入目标文件, 等待链接.&lt;/p&gt;
&lt;p&gt;其中, 预处理+解析语法树, 这两个过程, 在很多时候, 都是非常非常非常费时的操作. 虽然从语法树生成目标代码也非常耗时,但是如果不开启编译优化, 这个过程还是非常迅速的.&lt;/p&gt;
&lt;p&gt;不论开关优化, 预处理+解析语法树的时间, 是省不了的.&lt;/p&gt;</description>
    </item>
    <item>
      <title>让 C 回调支持 boost::bind</title>
      <link>https://microcai.org/2013/08/25/function-for-c-callback.html</link>
      <pubDate>Sun, 25 Aug 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/08/25/function-for-c-callback.html</guid>
      <description>&lt;p&gt;C++ 的 bind 非常方便! 但是如果你不得不处理一些 C 接口, 情况就会变得很糟糕, 你不得不处理一堆的 void* ,
不能使用 bind ! 有神码办法可以解决这个问题呢!? 答案就是 接下来介绍的模板技术 c_func_wraper !&lt;/p&gt;
&lt;p&gt;用法很简单, 看下面的例子&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;static&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;my_thread_func&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; a, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; b,  &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; c)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;cout &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  a &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  b &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  c &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;endl;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; NULL;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;main&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;[])
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	c_func_wraper&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;(&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;) (&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;),  &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;()&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; func;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	func &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;bind(&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;my_thread_func, &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;3&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	pthread_t new_thread;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	pthread_create(&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;new_thread, NULL, func.c_func_ptr(), func.c_void_ptr());
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	pthread_join(new_thread, NULL);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;pthread 是一个典型的 C 接口,  需要传递给线程的参数通过 void* 传递进来.  c_func_wraper 则将 bind 和 C 接口的回调给整合起来了!&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 7.1 发布</title>
      <link>https://microcai.org/2013/08/01/avbot-7.1.html</link>
      <pubDate>Thu, 01 Aug 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/08/01/avbot-7.1.html</guid>
      <description>&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;紧急更新，　TX 于 8 月　1　日晚上修改了登录协议，　导致　　avbot　全线瘫痪。所有的用户必须升级！必须升级！&lt;/p&gt;
&lt;p&gt;7.1　新增了慧眼答题平台支持。urlpreview 功能可以定义黑名单, 不对指定的url进行响应. 用法就是在　qqlog 目录下建立　blockurls.txt 文件，写入不希望avbot解析的正则表达式。&lt;/p&gt;
&lt;p&gt;avbot 的验证码识别功能详情请参考项目 &lt;a href=&#34;http://wiki.avplayer.org/deCAPTCHA&#34;&gt;wiki&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&#34;下面是-changelog&#34;&gt;下面是 Changelog&lt;/h2&gt;
&lt;p&gt;7.1
* run as -D , log to syslog
* 新增慧眼答题打码平台的支持
* urlpreview 功能可以定义黑名单, 不对指定的url进行响应.&lt;/p&gt;
&lt;p&gt;7.0
* 添加了两家印度阿三的分布式人肉验证码识别API支持
* 添加了AVPLAYER.ORG社区提供的无偿验证码识别服务支持
* 添加了联众打码平台的支持&lt;/p&gt;
&lt;p&gt;6.3
* httpagent.hpp merged to avhttp, use #include &amp;lt;avhttp/async_read_body.hpp&amp;gt;
* 日志部分使用 boost.log 重写
* 此版本开始要求 boost &amp;gt;= 1.54&lt;/p&gt;
&lt;p&gt;6.2
* 最后一个支持 boost &amp;lt;= 1.53 的版本. 下一个版本开始将要求 boost 1.54
* 重写了 http 处理代码
* fix joke segfault
* fix mail bug
* add back MSVC compiler support, only used to make jack happy. not intend to be production ready.&lt;/p&gt;</description>
    </item>
    <item>
      <title>GC是错误的内存管理模式</title>
      <link>https://microcai.org/2013/07/27/gc-is-wrong-way-of-doing-memory-managment.html</link>
      <pubDate>Sat, 27 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/27/gc-is-wrong-way-of-doing-memory-managment.html</guid>
      <description>&lt;p&gt;只要写程序,  就免不了要和各种资源打交道, 其中最频繁的莫过于内存了.&lt;/p&gt;
&lt;p&gt;任何一个程序都需要内存管理. 它不管是简单的还是复杂的, C 语言的还是 java 语言的. 所不一样的是, 内存管理的细节掌握在谁的手里.&lt;/p&gt;
&lt;p&gt;对于 C 语言, 毫无疑问的, 程序员掌握所有细节. 程序员获得了最大的灵活性, 作为代价, 编译器不对任何&lt;em&gt;&lt;strong&gt;内存管理上的疏忽&lt;/strong&gt;&lt;/em&gt;负责. 而人是 &lt;em&gt;最容易犯错&lt;/em&gt; 的生物. 意味着, 程序员总会犯错, 因此很难写出在内存管理上没有瑕疵的程序.&lt;/p&gt;
&lt;p&gt;毫无疑问的, 将内存管理的重担全部丢给程序员, 是编译器水平低下的时代无奈的选择. 随着编译器技术的发展, 将内存管理的任务从程序员手中接管是必然的.&lt;/p&gt;
&lt;p&gt;对于如何接管内存管理, 语言作者们分成了截然不同的两派&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;垃圾收集&lt;/li&gt;
&lt;li&gt;RAII (Resource Acquisition Is Initialization) + 智能指针&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;在带有垃圾收集的语言里, 程序员只管分配内存, 无需操心释放. 垃圾收集器间歇性的运作, 会将不再使用的内存释放掉. 至于如何标记哪些内存是不再使用的, 几十年间发展出了各种算法. 许多语言都带有多种标记算法供选择.  &amp;ldquo;没有哪一种垃圾收集策略是适合所有程序的, 所以各种语言都发展出多套垃圾收集器, 供运行时选择.&amp;rdquo;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;在许多语言里, 垃圾收集并不是编译器实现的, 而是由语言附带的运行时环境实现的, 编译器为运行时提供了附加的信息. 这就导致了语言和运行时的强耦合. 让人无法分清语言的特性和运行时的特性.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;垃圾收集不是完美的, 使用垃圾收集并不意味着就可以高枕无忧了.&lt;/strong&gt; 垃圾收集并不意味着内存泄漏成为过去式, 倒是野指针确实成为了过去式, 因为只要还有指针引用一个对象, 这个对象就绝对不会被释放. (不过, 带有垃圾收集的语言或多或少都废除了指针吧, 用引用替代了指针)&lt;/p&gt;
&lt;p&gt;有很多很多复杂的原因丢会导致垃圾收集器无法回收特定的内存, 导致这部分内存泄漏. 更严重的是, 你很难将内存泄漏和还未被清除的内存完全区别开来. 到底是&lt;strong&gt;延迟收集策略&lt;/strong&gt; 还是真的发生了&lt;strong&gt;内存泄漏&lt;/strong&gt;
?   你永远都无法正确分辨.&lt;/p&gt;</description>
    </item>
    <item>
      <title>C&#43;&#43; 闭包 探秘</title>
      <link>https://microcai.org/2013/07/20/closure.html</link>
      <pubDate>Sat, 20 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/20/closure.html</guid>
      <description>&lt;p&gt;我经常说协程, 说协程的时候又经常会提到闭包. 还有我常说, boost::bind 是神器  &lt;strong&gt;归根结底, 神的是  &amp;ldquo;闭包&amp;rdquo;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;没有闭包, 就无法实现 asio 协程 (注意, 我说的是 ASIO的协程, 并不是通常意义上 setjmp/longjmp 或者 CreateFiber 又或者 boost.context 创建的协程)&lt;/p&gt;
&lt;p&gt;每次使用 bind , 你就创建了一个闭包.&lt;/p&gt;
&lt;h1 id=&#34;简单的来说--闭包就是带状态的函数&#34;&gt;简单的来说,  闭包就是带状态的函数&lt;/h1&gt;
&lt;p&gt;一个函数, 带上了一个状态, 就变成了闭包了.  什么叫 &amp;ldquo;带上状态&amp;rdquo; 呢? 意思是这个闭包有属于自己的变量, 这些个变量的值是创建闭包的时候设置的, 并在调用闭包的时候, 可以访问这些变量.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;函数是代码, 状态是一组变量&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;将代码和一组变量捆绑 (bind) , 就形成了闭包&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;内部包含 static 变量的函数, 不是闭包, 因为这个 static 变量不能捆绑. 你不能捆绑不同的 static 变量. 这个在编译的时候已经确定了.  &lt;strong&gt;闭包的状态捆绑, 必须发生在运行时&lt;/strong&gt;.&lt;/p&gt;
&lt;h1 id=&#34;闭包的实现&#34;&gt;闭包的实现&lt;/h1&gt;
&lt;p&gt;C++　里使用闭包有３个办法&lt;/p&gt;
&lt;h2 id=&#34;重载--operator&#34;&gt;重载  operator()&lt;/h2&gt;
&lt;p&gt;因为闭包是一个函数+一个状态, 这个状态通过 隐含的 this 指针传入.  所以 闭包必然是一个函数对象.
因为成员变量就是极好的用于保存状态的工具, 因此实现 operator() 运算符重载, 该类的对象就能作为闭包使用.
默认传入的 this 指针提供了访问成员变量的途径.&lt;/p&gt;</description>
    </item>
    <item>
      <title>我为什么喜欢用协程</title>
      <link>https://microcai.org/2013/07/19/why-I-like-stackless-coroutine.html</link>
      <pubDate>Fri, 19 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/19/why-I-like-stackless-coroutine.html</guid>
      <description>&lt;p&gt;查看过 avbot 代码的人都知道, avbot 到处都是协程. 用句 ACG 的话来说,  &lt;em&gt;博士是&lt;strong&gt;协程控&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;那么, 为啥我会那么喜欢使用协程呢? 答案是协程大大简化了编程, 尤其是内存管理.&lt;/p&gt;
&lt;h2 id=&#34;协程简化了内存管理&#34;&gt;协程简化了内存管理&lt;/h2&gt;
&lt;p&gt;&lt;em&gt;写过异步程序的人都知道, 编写异步代码最容易犯的错就是内存泄露了.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;asio的无栈协程通过 &lt;strong&gt;闭包&lt;/strong&gt; 的形式, 将异步过程所要操作的资源绑定到 &lt;strong&gt;闭包&lt;/strong&gt; 上, 并使用 shared_ptr 对这些资源执行引用计数管理. 当最后一个回调执行完毕后, shared_ptr 确保了资源的正确释放. 对于 copyable 的资源, 甚至直接作为 &lt;strong&gt;闭包&lt;/strong&gt; 的一部分, 让资源随着闭包被 ASIO 拷贝, 释放, 拷贝, 释放, 最终最后一个&lt;strong&gt;闭包&lt;/strong&gt;完成使命, 彻底撤销.&lt;/p&gt;
&lt;p&gt;下面这个是 QQ 登陆过程的一个协程代码&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;// qq 登录办法-验证码登录
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;login_vc_op&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; result_type;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	login_vc_op(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;shared_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;qqimpl&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; webqq, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string _vccode, webqq&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;webqq_handler_t handler)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; m_webqq(webqq), vccode(_vccode), m_handler(handler)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string md5 &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; webqq_password_encode(m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_passwd, vccode, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_verifycode.uin);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#75715e&#34;&gt;// do login !
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string url &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;str(
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;format(
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;%s/login?u=%s&amp;amp;p=%s&amp;amp;verifycode=%s&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;webqq_type=%d&amp;amp;remember_uin=1&amp;amp;aid=%s&amp;amp;login2qq=1&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;u1=http%%3A%%2F%%2Fweb.qq.com%%2Floginproxy.html&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;%%3Flogin2qq%%3D1%%26webqq_type%%3D10&amp;amp;h=1&amp;amp;ptredirect=0&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;ptlang=2052&amp;amp;from_ui=1&amp;amp;pttype=1&amp;amp;dumy=&amp;amp;fp=loginerroralert&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;action=2-11-7438&amp;amp;mibao_css=m_webqq&amp;amp;t=1&amp;amp;g=1&amp;#34;&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; LWQQ_URL_LOGIN_HOST
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_qqnum
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; md5
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; vccode
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_status
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; APPID
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;						  );
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		m_stream &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;make_shared&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;http_stream&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;ref(m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice()));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		m_stream&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;request_options(
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;request_opts()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			(avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;http_options&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;cookie, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_cookies.lwcookies)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			(avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;http_options&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;connection, &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;close&amp;#34;&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		m_buffer &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;make_shared&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;streambuf&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;async_read_body(&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;m_stream, url, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;m_buffer, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// 在这里实现　QQ 的登录.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;operator&lt;/span&gt;()(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code ec, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;size_t bytes_transfered)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;istream response( m_buffer.get());
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;( ( check_login( ec, bytes_transfered ) &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt; ) &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; ( m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_status &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; LWQQ_STATUS_ONLINE ) )
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_clientid &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; generate_clientid();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#75715e&#34;&gt;//change status,  this is the last step for login
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#75715e&#34;&gt;// 设定在线状态.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;change_status(LWQQ_STATUS_ONLINE, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}&lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#66d9ef&#34;&gt;using&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;namespace&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;detail;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice().post(bind_handler(m_handler, ec));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// 登录完成 后的后续操作
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;operator&lt;/span&gt;()(&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; ec)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;using&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;namespace&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;detail;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;(ec)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice().post(bind_handler(m_handler, ec));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			BOOST_ASIO_CORO_REENTER(&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#75715e&#34;&gt;//polling group list
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				BOOST_ASIO_CORO_YIELD m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;update_group_list(&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#75715e&#34;&gt;// 每 10 分钟修改一下在线状态.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				lwqq_update_status(m_webqq, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_cookies.ptwebqq);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_group_msg_insending &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;!&lt;/span&gt;m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_msg_queue.empty();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;( m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_group_msg_insending )
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;					boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;tuple&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string, WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;send_group_message_cb&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; v &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_msg_queue.front();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;					boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;delayedcallms( m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice(), &lt;span style=&#34;color:#ae81ff&#34;&gt;500&lt;/span&gt;, boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;bind( &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;send_group_message_internal, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;shared_from_this(), boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;get&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;( v ), boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;get&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;( v ), boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;get&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;( v ) ) );
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;					m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_msg_queue.pop_front();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice().post(bind_handler(m_handler, ec));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;private&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string webqq_password_encode( &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; pwd, &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; vc, &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; uin)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#75715e&#34;&gt;//              ... 代码略 ...
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;private&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; check_login(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; ec, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;size_t bytes_transfered)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#75715e&#34;&gt;//              ... 代码略 ...
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;private&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;shared_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;qqimpl&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; m_webqq;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	webqq&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;webqq_handler_t m_handler;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	read_streamptr m_stream;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;shared_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;streambuf&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; m_buffer;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string vccode;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个协程里, 有的&lt;strong&gt;闭包&lt;/strong&gt;成员被 shared_ptr 管理, 有的没有.
这些资源, 统统都没有使用显式的内存管理, 而是让这些对象随着闭包的撤销被自动的析构.&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 的一些技术决定</title>
      <link>https://microcai.org/2013/07/17/some-technical-decision-about-avbot.html</link>
      <pubDate>Wed, 17 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/17/some-technical-decision-about-avbot.html</guid>
      <description>&lt;p&gt;avbot 早已实现最初的目标 : 提供一个机器把 IRC/XMPP和 QQ群联合起来. 让不使用QQ的人和只使用QQ的人都恩嗯畅快的交流.&lt;/p&gt;
&lt;p&gt;现在该歇息片刻, 回顾一下这一段历程, 以及编写avbot的时候所做的一些技术决定了.&lt;/p&gt;
&lt;h1 id=&#34;boostasio&#34;&gt;Boost.Asio&lt;/h1&gt;
&lt;p&gt;为什么 avbot 会使用 Boost 进行开发呢? Boost 有什么 好处? Asio 是干嘛的?&lt;/p&gt;
&lt;p&gt;我觉得对于 Asio,  &lt;a href=&#34;https://microcai.org/t/asio-jack-q/151/8&#34;&gt;Jack 的那篇讲座&lt;/a&gt;  足以解释的很清楚了.  Asio 是一个非常强大的网络库. 从一开始就选择了 Asio, 让 avbot 的后续开发不仅仅变得更轻松, 更重要的是, 我从 asio 那里学到了受用不尽的财富.&lt;/p&gt;
&lt;h1 id=&#34;avhttp&#34;&gt;avhttp&lt;/h1&gt;
&lt;p&gt;avhttp 可以说是 avbot 催生的一个项目. 如果不是 avbot , Jack 编写 avhttp 的动力也不是那么浓. 可能会更晚的时候开始编写, 也可能就不会开始编写.&lt;/p&gt;
&lt;p&gt;avhttp 是 Asio 思维的典型产物. 不过因为Jack个人喜好问题,  avhttp 里模板的使用还是太少了, 个人认为绝对是个遗憾.&lt;/p&gt;
&lt;p&gt;在使用 avhttp 之前, avbot 使用的HTTP网络库是 Urdl . 是个已经死掉的项目. avbot 不得不对 Urdl 进行了修改, 才让其支持了 Cookie 和一些其他 webqq 需要用到的 HTTP 头选项.&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 7.0-rc1 发布</title>
      <link>https://microcai.org/2013/07/11/avbot-7.0_rc1.html</link>
      <pubDate>Thu, 11 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/11/avbot-7.0_rc1.html</guid>
      <description>&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;就像博士说的, 不开发验证码解决方案不升级版本号, 这次主版本好不到一个月就被提升了, 咋回事呢?&lt;/p&gt;
&lt;p&gt;avbot 7.0 系列发布预览版&lt;a href=&#34;http://sourceforge.net/projects/avbot/files/sources/avbot-6.1.tar.bz2/download&#34;&gt;发布&lt;/a&gt;
了，同时发布的还有　&lt;a href=&#34;https://sourceforge.net/projects/avbot/files/rpm/&#34;&gt;rpm 包&lt;/a&gt;
和 &lt;a href=&#34;https://sourceforge.net/projects/avbot/files/win32/&#34;&gt;windows 包&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 7.0 添加了很多功能, 最重要的莫过于支持了验证码识别!&lt;/p&gt;
&lt;p&gt;avbot 的验证码识别功能详情请参考项目 &lt;a href=&#34;http://wiki.avplayer.org/deCAPTCHA&#34;&gt;wiki&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&#34;下面是-changelog&#34;&gt;下面是 Changelog&lt;/h2&gt;
&lt;p&gt;7.0-rc1
* 添加了两家印度阿三的分布式人肉验证码识别API支持
* 添加了AVPLAYER.ORG社区提供的无偿验证码识别服务支持&lt;/p&gt;
&lt;p&gt;6.3
* httpagent.hpp merged to avhttp, use #include &amp;lt;avhttp/async_read_body.hpp&amp;gt;
* 日志部分使用 boost.log 重写
* 此版本开始要求 boost &amp;gt;= 1.54&lt;/p&gt;
&lt;p&gt;6.2
* 最后一个支持 boost &amp;lt;= 1.53 的版本. 下一个版本开始将要求 boost 1.54
* 重写了 http 处理代码
* fix joke segfault
* fix mail bug
* add back MSVC compiler support, only used to make jack happy. not intend to be production ready.&lt;/p&gt;</description>
    </item>
    <item>
      <title>avplayer 维基站点建立</title>
      <link>https://microcai.org/2013/07/01/wiki-avplayer.html</link>
      <pubDate>Mon, 01 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/01/wiki-avplayer.html</guid>
      <description>&lt;p&gt;avplayer 社区的维基站点建立了, 欢迎大家访问  &lt;a href=&#34;http://wiki.avplayer.org&#34;&gt;http://wiki.avplayer.org&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;目前 avplayer 的维基站点开发免注册编辑权限. 大家可以把 avplayer 社区项目的一些心得分享进行编辑.&lt;/p&gt;
&lt;p&gt;比如在 windows 上如何编译 avbot, 希望辛苦解决的人能给后来人以提示.&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 6.1 发布</title>
      <link>https://microcai.org/2013/06/27/avbot-6.1.html</link>
      <pubDate>Thu, 27 Jun 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/06/27/avbot-6.1.html</guid>
      <description>&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 前不久悄悄迎来了半周岁的生日. 因此 avbot 也进入了 6.X 开发周期.&lt;/p&gt;
&lt;p&gt;avbot 6.0 系列第2个版本 6.1  &lt;a href=&#34;http://sourceforge.net/projects/avbot/files/sources/avbot-6.1.tar.bz2/download&#34;&gt;发布&lt;/a&gt;了，同时发布的还有　&lt;a href=&#34;https://sourceforge.net/projects/avbot/files/rpm/&#34;&gt;rpm 包&lt;/a&gt; 和 &lt;a href=&#34;https://sourceforge.net/projects/avbot/files/win32/&#34;&gt;windows 包&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 6.1 发布, 添加了股票报价功能, 另外也对 WebQQ 协议进行了更新.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&#34;下面是-changelog&#34;&gt;下面是 Changelog&lt;/h2&gt;
&lt;p&gt;6.1
* fix cookie process, make it more stable
* add stock price
* urlpreview now prevent noticing user the same url if the url is typed too fast
* urlpreview now parse the html escape character correctly&lt;/p&gt;
&lt;p&gt;6.0
* fix random relogin
* forward compatible with about to be released boost 1.54&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 5.1 发布</title>
      <link>https://microcai.org/2013/06/08/avbot-5.1.html</link>
      <pubDate>Sat, 08 Jun 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/06/08/avbot-5.1.html</guid>
      <description>&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 5.0 系列开始了.&lt;/p&gt;
&lt;p&gt;avbot 5.0 系列第3个版本 5.1  &lt;a href=&#34;http://sourceforge.net/projects/avbot/files/sources/avbot-5.1.tar.bz2/download&#34;&gt;发布&lt;/a&gt;了，同时发布的还有　&lt;a href=&#34;https://sourceforge.net/projects/avbot/files/rpm/&#34;&gt;rpm 包&lt;/a&gt; 和 &lt;a href=&#34;https://sourceforge.net/projects/avbot/files/win32/&#34;&gt;windows 包&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 的版本规则是, 每月提升一个大版本号, 因为是开发 avbot 的第 6 个月了, 所以大版本号提升到 5 了.&lt;/p&gt;
&lt;p&gt;avbot 5.1 发布, 修复了一个非常严重,困扰了我们很久的一个 100% CPU 占用问题.
当然, 5.0 版本也顺带跟随腾讯更新了群图片的图床API. 更新avbot后群图片获取不到的bug就消失了.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&#34;下面是-changelog&#34;&gt;下面是 Changelog&lt;/h2&gt;
&lt;p&gt;5.1
* fix 100% cpu bug&lt;/p&gt;
&lt;p&gt;5.0
* 支持白银黄金现货报价
* new icon set
* webqq: fix webqq group chat picture
* htmlog: distribute image files to sub dirs.
* libwebqq: move cache file to cache/ sub directory&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 4.7 更新</title>
      <link>https://microcai.org/2013/05/08/avbot-4.7.html</link>
      <pubDate>Wed, 08 May 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/05/08/avbot-4.7.html</guid>
      <description>&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 4.0 系列第九个版本 4.7  &lt;a href=&#34;http://sourceforge.net/projects/avbot/files/sources/avbot-4.7.tar.gz/download&#34;&gt;发布&lt;/a&gt;了，同时发布的还有　&lt;a href=&#34;https://sourceforge.net/projects/avbot/files/rpm/&#34;&gt;rpm 包&lt;/a&gt; 和 &lt;a href=&#34;https://sourceforge.net/projects/avbot/files/win32/&#34;&gt;windows 包&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;rpm 包有 x86_32（用于64位系统） 的和 i686 （用于32位系统） 两个版本。其实 rpm 包解压一下也可以用在 Deb 系的系统上。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;PS: sourceforge 上的 avbot　项目我开通了匿名上传权限，欢迎大家提交　deb/rpm 包供大家下载。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;4.7 版本带来的最大的变化莫过于带来了 &amp;ldquo;自动群公告支持&amp;rdquo;. 配置一下就能支持每天定时的发送一些设定好的消息.&lt;/p&gt;
&lt;p&gt;接着是完善了实验性的 lua 脚本支持 (通过 &amp;ndash;enable-lua 启用)&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&#34;下面是-changelog&#34;&gt;下面是 Changelog&lt;/h2&gt;
&lt;p&gt;4.7
* bulletin: broadcast a bulletin message @ desired time
* win32: settings dialog make irc optional
* htmlog: log HTML correttly.
* lua: add more lua example code.&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 4.6.1 更新</title>
      <link>https://microcai.org/2013/05/04/avbot-4.6.html</link>
      <pubDate>Sat, 04 May 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/05/04/avbot-4.6.html</guid>
      <description>&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 4.0 系列第八个版本 4.6.1  &lt;a href=&#34;http://sourceforge.net/projects/avbot/files/sources/avbot-4.6.1.tar.bz2/download&#34;&gt;发布&lt;/a&gt;了，同时发布的还有　&lt;a href=&#34;https://sourceforge.net/projects/avbot/files/rpm/&#34;&gt;rpm 包&lt;/a&gt; 和 &lt;a href=&#34;https://sourceforge.net/projects/avbot/files/win32/&#34;&gt;windows 包&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;rpm 包有 x86_32（用于64位系统） 的和 i686 （用于32位系统） 两个版本。其实 rpm 包解压一下也可以用在 Deb 系的系统上。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;PS: sourceforge 上的 avbot　项目我开通了匿名上传权限，欢迎大家提交　deb/rpm 包供大家下载。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;4.6 版本带来的最大的变化就是支持了 URL 预览功能. 当有群友贴出一个 URL 的时候, avbot 智能的将 url 解析并贴出网页标题.&lt;/p&gt;
&lt;p&gt;接着是加入了实验性的 lua 脚本支持 (通过 &amp;ndash;enable-lua 启用)&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id=&#34;下面是-changelog&#34;&gt;下面是 Changelog&lt;/h2&gt;
&lt;p&gt;4.6
* allow to -c to specify the location of the config file
* automantically show url content then some one post an url
* change .qqbot newbee command to .qqbot welcome
* add experimental support for luascripting&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 4.5 紧急更新</title>
      <link>https://microcai.org/2013/05/02/avbot-4.5.html</link>
      <pubDate>Thu, 02 May 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/05/02/avbot-4.5.html</guid>
      <description>&lt;ul&gt;
&lt;li&gt;avbot 4.5 是一个紧急更新版本， 所有用户都应该升级。 因为TX的WebQQ协议有变动， 会导致无法获取群列表。*&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;对于不知道　avbot 是神码的同学，猛击&lt;a href=&#34;http://qqbot.avplayer.org&#34;&gt;这里&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;avbot 4.0 系列第六个版本 4.5  &lt;a href=&#34;http://sourceforge.net/projects/avbot/files/sources/avbot-4.5.tar.bz2/download&#34;&gt;发布&lt;/a&gt;了，同时发布的还有　&lt;a href=&#34;https://sourceforge.net/projects/avbot/files/rpm/&#34;&gt;rpm 包&lt;/a&gt; 和 &lt;a href=&#34;https://sourceforge.net/projects/avbot/files/win32/&#34;&gt;windows 包&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;rpm 包有 x86_32（用于64位系统） 的和 i686 （用于32位系统） 两个版本。其实 rpm 包解压一下也可以用在 Deb 系的系统上。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;PS: sourceforge 上的 avbot　项目我开通了匿名上传权限，欢迎大家提交　deb/rpm 包供大家下载。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;What&amp;rsquo;s NEW in this release ?&lt;/p&gt;
&lt;p&gt;4.5
* sync webqq protocol
* clean cache file when startup
* a bug that cause xmpp account accidently not used&lt;/p&gt;
&lt;p&gt;4.4
* fix a bug that new group is not created automantically
* 自动欢迎新人使用的是 &lt;code&gt;$qqlogdir/$qqgroup/welcome.txt&lt;/code&gt; 的内容
* 新人加群自动欢迎新人
* try to re-fetch the joke page if decoding error occurs&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 4.2 新功能解释和实现</title>
      <link>https://microcai.org/2013/04/29/avbot-new-feature-autojoke.html</link>
      <pubDate>Mon, 29 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/29/avbot-new-feature-autojoke.html</guid>
      <description>&lt;h1 id=&#34;新功能---讲笑话&#34;&gt;新功能 - 讲笑话&lt;/h1&gt;
&lt;p&gt;这是一个早就被呼吁的功能，今天抽空实现了。笑话这个功能实现起来有2个要点：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;第一，这个笑话虽然是隔十分钟讲一次，可是不能打断大家的讨论，所以是出现十分钟的空闲后才发&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;第二，这个笑话需要从网页上抓取&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;第一个要点, 使用办法就是 Asio 提供的 deadline_timer.
设定定时器超时 10min , 但是如果有人发言, 就重设时间. 通过链接到 avbot::on_message 就可以知道有没有人发言了.&lt;/p&gt;
&lt;p&gt;实现起来非常简单,就是在 on_message 的时候重新设定定时器.&lt;/p&gt;
&lt;p&gt;第二,笑话要从网上抓取. 这个使用了&lt;a href=&#34;http://github.com/ericsimith/avjoke&#34;&gt;徒弟&lt;/a&gt;写的解析代码了. 不过咱高级,使用的是 avhttp 进行 HTTP 访问. 徒弟他不懂事, 手写 HTTP 解析.&lt;/p&gt;
&lt;hr&gt;
&lt;h1 id=&#34;实现&#34;&gt;实现&lt;/h1&gt;
&lt;p&gt;将笑话模块实现为一个 class joke,  class joke 重载了 operator(), 也就是说,是个仿函数,本身就可以作为 on_message 的 slot . class joke 重载了多个 operator() , 一个用于 on_message 的 slot , 一个用户 deadline_timer 的 Handler.&lt;/p&gt;
&lt;p&gt;在用作 on_message 的 slot 的 operator() 里, joke 就做了一件事: 重设 timer
在 deadline_timer 的 Handler 里, 首先判断 timer 是到期了还是取消了. 取消的 timer 啥也 不干.&lt;/p&gt;</description>
    </item>
    <item>
      <title>avbot 结构解释</title>
      <link>https://microcai.org/2013/04/28/avbot-struct.html</link>
      <pubDate>Sun, 28 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/28/avbot-struct.html</guid>
      <description>&lt;p&gt;avbot 由 4 大部分构成 libavbot libavlog botctl avbotrpc&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;   +----------+            +----------+        +----------+
   | libavlog |            | libavbot | ---+---| libwebqq |
   +----------+\         / +----------+    |   +----------+
                 main.cpp                  |   
   +----------+/         \ +----------+    |   +----------+
   |  botctl  |           \| avbotrpc |    +---| libxmpp  |  
   +----------+            +----------+    |   +----------+
                                           |
                                           |   +----------+
                                           +---+  libirc  |
                                           |   +----------+
                                           |
                                           |   +------------------+
                                           +---+  libmailexchange |
                                               +------------------+
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;中间由 main.cpp 作为胶水粘合。&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;libavlog 的任务是生成日志文件，botctl 的用处是实现 .qqbot 控制指令。
avbotrcp 用于实现 JSON-RPC&lt;/p&gt;</description>
    </item>
    <item>
      <title>用概念编程</title>
      <link>https://microcai.org/2013/04/27/coding-by-concepts.html</link>
      <pubDate>Sat, 27 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/27/coding-by-concepts.html</guid>
      <description>&lt;p&gt;C++ 爸爸对 c++11 提出了一个 “模板概念” 提案，可是又亲自否决了它。因为他觉得还不够好，还要继续研究一番才行。C++是一个严谨的语言，新特性的加入要小心谨慎。&lt;/p&gt;
&lt;p&gt;虽然提案没有通过，但是，C++爸爸俨然已经将那个 C with Class 的语言进化了，C++不再是一个 C with Class 的语言，而是迈出了“概念”编程的一步。&lt;/p&gt;
&lt;p&gt;概念编程在C++中由来已久，C++爸爸的提案就是为了在语言级更好的支持概念编程。在语言没有支持到家的时候，通过修修补补，也还是能将就使用。&lt;/p&gt;
&lt;p&gt;什么是用概念编程呢？ 简单的来说，就是弱化类型，强调概念。比如 std::sort , 它的参数是什么呢？ 他的参数可以是任何一种迭代器所表示的区间。任何类型的迭代器都可以。不论是指向int的还是string的还是你自己定义的类。这就是 std::sort 所需要的参数的概念。因为在人脑中，对一样东西排序可不需要知道他是数组还是链表。std::sort 对于 迭代器指向的对象也有一个要求：必须能比较大小。不能比较大小的东西还能排序么？&lt;/p&gt;
&lt;p&gt;那么这就是 std::sort 所提出的概念要求。以概念编程，就越来越接近人脑的思维。人不再需要将抽象的概念具像为C语言中的基本类型。&lt;/p&gt;
&lt;p&gt;前段时间我写的 &lt;a href=&#34;https://microcai.org/2013/03/28/boost-base64.html&#34;&gt;boost 编码 base64&lt;/a&gt; 也是概念编程的产物。因为你不用再幸苦的思索base64的编码算法了。只要依据 base64 的描述就可以写出编解码的代码了。&lt;/p&gt;
&lt;p&gt;根据base64概念，编码过程就是 6bit 为一个单位，然后转化为 ASCII 字符。那么就简单了，你需要一个将输入流转化为6bit的迭代器。也就是 boost::archive::iterators::transform_width 这个迭代器，模板参数区分别是 6, 8, char。接着你获得了 6bit 的数据，然后通过base64_from_binary这个迭代器输入6bit数据输出ASCII编码。&lt;/p&gt;
&lt;p&gt;将迭代器嵌套起来，就就获得了一个 base64 编码器了。 base64_from_binary&amp;lt;transform_width&amp;lt;6,8,char&amp;gt; &amp;gt; 就是一个 base64 编码的迭代器了。输入二进制数据，输出base64编码的数据。有使用 ，你还需要每78个字符换行，那么简单到再嵌入一个 boost::archive::iterators::insert_linebreaks 就可以自动的插入换行符了！&lt;/p&gt;
&lt;p&gt;同样的，一个 base64 解码器也非常简单，首先是一个 boost::archive::iterators::remove_whitespace 迭代器，移除空白字符，如那个每78字符换行，然后是 boost::archive::iterators::binary_from_base64 从 ASCII 生成 6bit数据，接着是 boost::archive::iterators::transform_width 和编码反过来，模板参数为 &amp;lt;8, 6, char&amp;gt; 将6bit输入拼成8bit输出。&lt;/p&gt;</description>
    </item>
    <item>
      <title>ASIO 与协程</title>
      <link>https://microcai.org/2013/04/22/asio-statemachine.html</link>
      <pubDate>Mon, 22 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/22/asio-statemachine.html</guid>
      <description>&lt;p&gt;前段时间看了 ASIO 爸爸关于ASIO的一个演讲. ASIO 爸爸说, ASIO 的设计理念就是作为一个 toolkit 而不是一个框架. ASIO并不强迫你使用某种编程模型. 它只是提供一系列的函数和类帮你更容易的编程.&lt;/p&gt;
&lt;p&gt;ASIO 的设计思想其实和 GLIB 的 g_main_loop 非常像. 但是 C++ 因为有模板, 所以能更好的实现. 使用 g_main_loop 的时候, 我不记得我写了多少 void* 到 struct 的转化了. 这就是 C 的弊病. 因为缺少模板,所以回调必须严格符合函数签名. 但是库作者永远想不到用户还需要什么样的参数. 于是void*就是最好的解决办法了.&lt;/p&gt;
&lt;p&gt;但是因为 C++ 有模板,所以放松了对函数签名的要求. 不符合 ASIO 回调函数签名要求的,都可以使用 bind 绑定以符合签名要求. 这就为库的使用者带来了巨大的灵活性的同时仍然保持极佳的易用性.&lt;/p&gt;
&lt;p&gt;C++的另一个强大优势即是函数对象(bind的结果就是一个函数对象). 通过函数对象, 使得一些状态可以保存到成员变量中, 这样就给了我们一个不需要栈就实现的一个协程. 协程本质上是一个拥有多重入口和多重出口的函数. 每次调用都将从上一次退出的地方继续执行. 如果没有成员变量, 所有的变量都将保持于栈上, 这就要求协程的实现必定带来栈切换. 而栈的要求就导致协程必须有额外的创建和撤销动作. 这都给协程的实际使用造成了限制.&lt;/p&gt;
&lt;p&gt;C++的函数对象, 既可以像普通函数那样调用, 又可以像通常的对象那样携带成员变量. 因此通过将变量置于对象而不是栈上, C++就可以实现无栈协程. 无栈协程的开销不过就是一个函数对象, 而无需一次性分配一个巨大的内存用于栈. 通常一个栈实现的协程,需要分配一个 1MB~10MB 的内存用于栈. 而无栈协程所使用的对象,不过就只是一个函数对象,通常大小不过几个字节到几百字节. 因此无栈协程允许创建大量的协程,而无需当心内存开销.&lt;/p&gt;
&lt;p&gt;ASIO 爸爸即创造性的提出了无栈协程的概念, 然后将它用于实践中.&lt;/p&gt;</description>
    </item>
    <item>
      <title>NVIDIA 官方驱动支持 Optimus</title>
      <link>https://microcai.org/2013/04/15/nvidia-optimus.html</link>
      <pubDate>Mon, 15 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/15/nvidia-optimus.html</guid>
      <description>&lt;p&gt;各位，鄙人去年手贱，买了台 Optimus 的笔记本。最开始的时候用的 Bumblebee，但是觉得每
次用 optirun  非常的 egg pain。我想全局启用 NVIDIA 显卡（GT650M显卡买来不用浪费
啊！），而不是手动使用 optirun。&lt;/p&gt;
&lt;p&gt;于是我折腾了  DRM/PRIME , 跑起了开源驱动，找到了PRIME的各种补丁，然后编译+折腾。终于
搞定。&lt;/p&gt;
&lt;p&gt;虽然性能差了点（直到昨天我才知道，差的实现相当的大啊！）好歹比集显好多了。&lt;/p&gt;
&lt;p&gt;前些天，NVIDIA 发布了  319.12 驱动，官方支持了 PRIME 和 xrandr 1.4  !&lt;/p&gt;
&lt;p&gt;我乐死了，赶紧折腾。现在分享一下成功经验： PSGentoo下会easy很多。&lt;/p&gt;
&lt;p&gt;首先，第一重要的是确保自己使用的是  3.9 内核。开启 intel 的 KMS , 去掉 nouveau 驱动。&lt;/p&gt;
&lt;p&gt;然后确保 xorg  是最新版 !  xorg-server &amp;gt;= 1.13 !&lt;br&gt;
确保 xrandr 是最新版！ xrandr &amp;gt;= 1.4 !&lt;/p&gt;
&lt;p&gt;然后，要使用 xf86-video-modesetting !! 而不是 xf86-video-intel ，记住！！ 很重要！&lt;/p&gt;
&lt;p&gt;emerge xf86-video-modesetting&lt;/p&gt;
&lt;p&gt;好了，非常关键的，需要 nvidia-drivers &amp;gt;= 319.12 !&lt;/p&gt;
&lt;p&gt;你需要做的就是 在 /etc/portage/package.unmask 解除 nvidia-drivers &amp;gt;= 319.12 版本的屏蔽.
然后再安装&lt;/p&gt;</description>
    </item>
    <item>
      <title>ASIO协程的思维转变</title>
      <link>https://microcai.org/2013/04/13/asio-stackless-coroutine-meaning.html</link>
      <pubDate>Sat, 13 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/13/asio-stackless-coroutine-meaning.html</guid>
      <description>&lt;p&gt;avbot 是一个纯粹的单线程程序。在设计 avbot 最初的时候，我就给自己下了一个明确的目标：必须单线程。&lt;/p&gt;
&lt;p&gt;但是，它的逻辑可不简单。它需要处理 XMPP 协议，处理 IRC 协议，处理 WebQQ 协议，处理pop3协议，处理 SMTP 协议。
所有的处理都必须异步。绝对不能因为 IO 阻塞。&lt;/p&gt;
&lt;p&gt;可能很多人会不以为然，这有什么， select() 一下就好了。但是你知道这意味着多少代码么？&lt;/p&gt;
&lt;p&gt;你需要编写大量的函数，大量的回调函数。别说复杂的 WebQQ 协议了，就是一个简单的 IRC , 你知道要多少代码完成异步处理么？&lt;/p&gt;
&lt;p&gt;而且除了 WebQQ 以外（WebQQ的代理支持也在添加计划中）， XMPP IRC POP3 SMTP 都是支持代理的。你知道要多少代码完成代理么？&lt;/p&gt;
&lt;p&gt;想必很多吧？&lt;/p&gt;
&lt;p&gt;所幸的是，avbot 没有使用C开发，也没有选择 ACE MFC 这样的不合格的类库开发。而是选择了 Boost。尤其是 ASIO, ASIO让异步过程大大简化。&lt;/p&gt;
&lt;p&gt;而让异步过程更加简化的，就是 ASIO 作者发明的 stackless coroutine!&lt;/p&gt;
&lt;p&gt;avbot 发布了许久了， 最近突然有个用户跑来说，希望能增加个调用 “外部脚本” 的功能，方便扩展。&lt;/p&gt;
&lt;p&gt;我一向对设计一个 plugin 机制极力的避免，不喜欢动态载入的模块扩展程序本身的功能。何况 avbot 是 c++开发的，调用脚本并不是容易的事情。（好吧，真实的原因是我被 mingw （VC 不支持 utf8源码，我已经抛弃了） 折腾怕了，不想再搞个 python 。windows实在是恐怖的平台，写点程序麻烦的要死，编译麻烦的要死。可是 avbot 又必须跨平台，结果是我一天写好的东西要在 windows (虚拟机) 里折腾好几天，累死人 ）&lt;/p&gt;</description>
    </item>
    <item>
      <title>fcitx 违反了 GPL2 ? (更新, 已解决)</title>
      <link>https://microcai.org/2013/04/06/fcitx-gpl-valation.html</link>
      <pubDate>Sat, 06 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/06/fcitx-gpl-valation.html</guid>
      <description>&lt;p&gt;fcitx 是 yuking 的作品。 一直以来都是以 GPL2 协议发布。&lt;/p&gt;
&lt;p&gt;yuking 后来将维护权交给了 csslayer. csslayer 开始了 fcitx 4.X 系列的维护工作。&lt;/p&gt;
&lt;p&gt;最近我查看了fcitx 4 的协议， 发现 fcitx4 将自己的协议降级了。而且降级并没有说明获得过 yuking 和其他贡献者的同意。&lt;/p&gt;
&lt;p&gt;按照 GPL2 的协议， 升级(就是变得比GPL2 还要严格，比如升级到 GPL3)是被允许的。 但是降级（也就是提出了可以不遵守GPL2的例外）显然是不被允许的。&lt;/p&gt;
&lt;p&gt;按照通行法则，软件作者具备更改授权的权利。那么 csslayer 具备这个更改授权的权利么？
那就要看 fcitx 是不是 csslayer 的个人作品了。如果 fcitx 包含了许多人的工作，那么 csslayer 要更改 fcitx 的协议就必须获得所有 fcitx 贡献者的首肯。&lt;/p&gt;
&lt;p&gt;明显 fcitx 4 更改协议的时候并没有获得yuking 和其他贡献者的同意。如果确实获得了他们的同意，我希望 csslayer 能公开声明获得了他们的同意。&lt;/p&gt;
&lt;hr&gt;
&lt;h1 id=&#34;更新&#34;&gt;更新&lt;/h1&gt;
&lt;p&gt;傲慢的 csslayer 承认了错误，向 yuking 获得了同意。参考 &lt;a href=&#34;http://uploads.csslayer.info/uploads/mail/mail.mbox&#34;&gt;这个邮件&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;现在 fcitx 应该没什么大问题了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>模板多态</title>
      <link>https://microcai.org/2013/04/05/template-as-polymiorphism.html</link>
      <pubDate>Fri, 05 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/05/template-as-polymiorphism.html</guid>
      <description>&lt;h1 id=&#34;需求&#34;&gt;需求&lt;/h1&gt;
&lt;p&gt;jack 正在实现一个 avhttp , 并且也已经相当的可用了。 他在实现http协议的时候，就对 HTTPS 和 HTTP 的实现做了一个相当重要的决定 &amp;mdash;&amp;ndash; HTTPS和HTTP必须是统一的代码。&lt;/p&gt;
&lt;p&gt;那么，要优雅的做到这一点，显然只有一个办法：多态。&lt;/p&gt;
&lt;p&gt;但是很不幸的是，SSL 需要 asio::ssl::ssl_stream , 而 TCP 则用的是 asio::ip::tcp::socket。于是 jack 想到了boost::variant。 这是一个支持 非POD成员作为一个 unin 的库解决方案。&lt;/p&gt;
&lt;p&gt;很不幸，即便如此， SSL 和 TCP 仍然有相当多的代码不能公用。然后对于代理服务器的支持， SSL 和 TCP 就更不能统一处理。&lt;/p&gt;
&lt;p&gt;依然要相当多的条件分支。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;就不能有一个更干净的办法么？
&lt;/code&gt;&lt;/pre&gt;
&lt;h1 id=&#34;分层实现&#34;&gt;分层实现&lt;/h1&gt;
&lt;p&gt;于是我提出了将 avhttp 中 HTTP 请求过程分两层实现，一个是 DNS查询、TCP 链接的发起、代理服务器握手、SSL 握手等一系列的步骤。 也就是说，在真正的发起一次 HTTP 请求之前的一系列操作将其归类到第一层。接着，是第二层，就是真正的 HTTP 协议处理了。&lt;/p&gt;
&lt;p&gt;那么第一层，无论是 HTTPS 还是 HTTP， 几乎肯定都是和 TCP 打交道，只有最后一步 HTTPS 多了一个 SSL 握手， 而 HTTP 则不需要。 这样， 第一层，不论是 HTTPS 还是 HTTP，只有唯一一处条件判断选择 SSL 握手这个分支语句。&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入理解C&#43;&#43;</title>
      <link>https://microcai.org/2013/04/02/deepunderstandingcpp.html</link>
      <pubDate>Tue, 02 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/02/deepunderstandingcpp.html</guid>
      <description>&lt;p&gt;说一下我为何回归 C++ 了吧 : 简单: 生命有限。&lt;/p&gt;
&lt;p&gt;用 C , 固然是只有一个范式, 学起来容易, 上手简单， 可是需要操心的问题太多了: 内存泄露, 野指针, 各种断错误。
可能你会说, 内存管理，小心点就可以了。
但我觉得,如果你总是用 200% 的精力去避免内存泄露，你就没有精力开发正常的软件了。你会对软件的逻辑进行折中，因为你实在没有精力开发需要你花很多时间写逻辑的代码了。
于是, 各种因为&amp;quot;实现起来麻烦&amp;quot; 为借口进行功能精简。所以我重新拿起了高级语言。&lt;/p&gt;
&lt;p&gt;那么, 就面临者选择: 1 c++ 2 python 3 java etc&lt;/p&gt;
&lt;h1 id=&#34;那么-为啥选择了-c-呢--因为-c-的抽象能力是所有语言中最高的&#34;&gt;那么, 为啥选择了 c++ 呢? —— 因为 C++ 的抽象能力是所有语言中最高的&lt;/h1&gt;
&lt;p&gt;我为啥怎么说呢？&lt;/p&gt;
&lt;h2 id=&#34;你比如说java为啥java是个烂语言呢&#34;&gt;你比如说java,为啥java是个烂语言呢&lt;/h2&gt;
&lt;p&gt;&lt;em&gt;这个和jvm无关&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;博士说过性能问题是狗屎, 我不喜欢考虑性能问题。 java的烂和jvm无关。&lt;/p&gt;
&lt;h2 id=&#34;java-烂就烂在-gc-和面向对象&#34;&gt;java 烂就烂在 GC 和面向对象&lt;/h2&gt;
&lt;p&gt;面向对象+GC 就组合成了一个臭不可闻的烂语言。&lt;/p&gt;
&lt;h3 id=&#34;为啥-gc-和面向对象被我那么贬低呢&#34;&gt;为啥 GC 和面向对象被我那么贬低呢?&lt;/h3&gt;
&lt;p&gt;&lt;em&gt;因为 对象 的抽象能力实在是太弱了, 并且也不是正确的抽象&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;比如 人&lt;/p&gt;
&lt;p&gt;你要用 class human 抽象?&lt;/p&gt;
&lt;p&gt;那人能干啥?&lt;/p&gt;
&lt;p&gt;这都是你不得不考虑的问题&lt;/p&gt;
&lt;p&gt;还有&lt;/p&gt;
&lt;p&gt;你觉得应该搞继承&lt;/p&gt;
&lt;p&gt;然后人从 哺乳动物继承&lt;/p&gt;</description>
    </item>
    <item>
      <title>随机编程</title>
      <link>https://microcai.org/2013/04/01/random-programming.html</link>
      <pubDate>Mon, 01 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/01/random-programming.html</guid>
      <description>&lt;p&gt;这个想法由来已久, 是从和  &lt;a href=&#34;http://codedoom.net&#34;&gt;Jack&lt;/a&gt; 的多次交谈中逐渐悟出来的天朝程序员惯用编程模式.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;所谓随机编程, 就是 _随机的_ 改动一些代码, 以求程序运行通过. 但是并不知道为啥这样修改程序就能工作了.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;随机编程严重的依赖于&lt;em&gt;单元测试&lt;/em&gt;. 给测试人员带来极大的负担.&lt;/p&gt;
&lt;p&gt;随机编程的程序员, 对问题不求甚解. 以通过测试为编程目标. 出现问题就一头扎进 &lt;em&gt;改代码&lt;/em&gt; 的 &lt;em&gt;重复性&lt;/em&gt; &lt;em&gt;随机性&lt;/em&gt; 工作中
为啥一个简单的bug需要那么长时间的修复? 还要程序员加班加点?&lt;/p&gt;
&lt;p&gt;因为他们要随机编程, 随机性的修改, 通过 &lt;em&gt;大量的&lt;/em&gt; 修改, 总有一次修改是正确的.&lt;/p&gt;
&lt;p&gt;有时他们 &lt;em&gt;为了&lt;/em&gt; 减轻这种机械劳动的负担, 使用了自动化的工具做测试, 是为 &lt;em&gt;单元测试&lt;/em&gt; .&lt;/p&gt;
&lt;p&gt;依据单元测试, 如果有一群猴子花无数年的时间, 总有一天他们能写出 &lt;em&gt;正常工作&lt;/em&gt; 的代码.&lt;/p&gt;
&lt;p&gt;如果一个公司异常的强调单元测试, 那么他的程序员一定是 猴子级别的. 只要他们不停的写代码, 总有一天他们能写出通过单元测试的 &lt;em&gt;正常工作&lt;/em&gt; 的代码.&lt;/p&gt;
&lt;p&gt;即便他们的程序员有不是猴子的, 管理员也是把他们当成猴子, 因为管理层不想依赖 &lt;em&gt;程序员&lt;/em&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>使用 boost 执行 base64 解码</title>
      <link>https://microcai.org/2013/03/28/boost-base64.html</link>
      <pubDate>Thu, 28 Mar 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/03/28/boost-base64.html</guid>
      <description>&lt;p&gt;&lt;a href=&#34;http://en.wikipedia.org/wiki/Base64&#34;&gt;base64&lt;/a&gt; 编码最初是为了电子邮件开发的。因为电子邮件是个文本协议，不能传输二进制数据，甚至中文也无法进行传输。只能传输ascii编码的文本。这样一来就诞生了多种将二进制数据编码到ascii里的编码方案，base64是其中之一。&lt;/p&gt;
&lt;p&gt;base64是一种非常简单的编码，只要进行一次迭代即可完成解码。&lt;/p&gt;
&lt;p&gt;什么？一次迭代？？？&lt;/p&gt;
&lt;p&gt;这就让我们有机会借助 Boost 提供的迭代器非常简洁的写出base64解码器。&lt;/p&gt;
&lt;p&gt;Boost 提供了一个叫 boost::archive::iterators::binary_from_base64 的迭代器。但是直接使用它并不能完成 base64解码。&lt;/p&gt;
&lt;p&gt;还应该外面再套一层 archive::iterators::transform_width 以 6bit 为单位转换到 8bit。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;typedef	archive::iterators::transform_width&amp;lt; 
		archive::iterators::binary_from_base64&amp;lt;const char* &amp;gt;, 8, 6, char&amp;gt;
			base64decodeIterator;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么这个就应该是用于解码的 base64decodeIterator&lt;/p&gt;
&lt;p&gt;但是，稍等。如果用来解码电子邮件里的东西，会经常出异常，说有不能允许的字符出现在了base64输入里。&lt;/p&gt;
&lt;p&gt;为什么呢？ 因为电子邮件以 78个字符断行了。也就是出现了base64里不允许的 CRLF。&lt;/p&gt;
&lt;p&gt;那么，怎么办？ 解码前先替换删除 CRLF ?&lt;/p&gt;
&lt;p&gt;非也非也，这么做是愚蠢的哦，因为我们要的就是一次迭代的效果。
所以，archive::iterators::binary_from_base64&amp;lt;const char* &amp;gt; 使用的是 const char * 这个迭代器，对吧，我们改一下，使用 boost::filter_iterator 这个迭代器。过滤掉非base64编码字符。&lt;/p&gt;
&lt;p&gt;boost::filter_iterator 需要使用一个模板参数，参数是一个过滤用的仿函数。&lt;/p&gt;
&lt;p&gt;于是我们写一个&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct is_base64_char {
bool operator()(char x) { return boost::is_any_of(&amp;quot;0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/=&amp;quot;)(x);}
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后使用     boost::filter_iterator&amp;lt;is_base64_char, const char*&amp;gt; 作为 archive::iterators::binary_from_base64 的迭代器，就形如&lt;/p&gt;</description>
    </item>
    <item>
      <title>在高处编程</title>
      <link>https://microcai.org/2013/03/26/stayhigher.html</link>
      <pubDate>Tue, 26 Mar 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/03/26/stayhigher.html</guid>
      <description>&lt;p&gt;C++之父在一个讲座上说过，C++是一门轻量级的抽象语言。轻量级，意味着C++尽量减小因为多加的抽象带来的负担。抽象语言，意味着C++有着很强的抽象能力，C++的抽象能力，有了BOOST这样的库之后被极大的提升了，配合着BOOST, 我将 C++称呼为 &lt;em&gt;编译型脚本&lt;/em&gt;。&lt;/p&gt;
&lt;p&gt;C++是一门抽象语言，使用C++的时候，千万不要去思考编译器到底是如何安排内存的。认真你就输了。使用C++的时候，千万不要去思考，到底对象如何创建，如何/何时撤销的。认真你就输了。你一定要在心里这么想：这么用就是我要的。不要去想到底发生了什么。如下面的代码&lt;/p&gt;
  &lt;script src=&#34;https://gist.github.com/microcai/5243264.js&#34;&gt;&lt;/script&gt;
&lt;p&gt;这样的代码，千万不要去思考内存的分配，std::string 的实现过程，== 运算符怎么实现的。你唯一关心的问题就是：这样一段代码是否&lt;em&gt;表达&lt;/em&gt;了你心里所想的。这一段代码是否表达了你心里所要做的事情。&lt;/p&gt;
&lt;p&gt;如果是，请千万不要考虑如何写能&lt;em&gt;更快&lt;/em&gt;。请一定要&lt;em&gt;相信编译器&lt;/em&gt;，编译器知道了你的想法后，一定会生成最优化的代码。&lt;/p&gt;
&lt;p&gt;有的人说，使用了BOOST之后，编译很慢。编译慢，说明编译器在编译期执行了大量的工作。编译期做的事情越多，意味着运行期做的事情越少。不要怀疑编译的能力。&lt;/p&gt;
&lt;p&gt;C++是一门轻量级的抽象语言，请站在高处进行思维，请相信编译器的优化。&lt;/p&gt;</description>
    </item>
    <item>
      <title>无栈协程</title>
      <link>https://microcai.org/2013/03/17/stackless-coroutine.html</link>
      <pubDate>Sun, 17 Mar 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/03/17/stackless-coroutine.html</guid>
      <description>&lt;p&gt;在开始之前，先来看一段代码　&lt;/p&gt;
&lt;pre style=&#39;color:#1f1c1b;background-color:#ffffff;&#39;&gt;
&lt;span style=&#39;color:#0057ae;&#39;&gt;void&lt;/span&gt; pop3::&lt;b&gt;operator&lt;/b&gt;() ( &lt;span style=&#39;color:#0057ae;&#39;&gt;const&lt;/span&gt; boost::system::error_code&amp;amp; ec, std::size_t length )
{
	&lt;b&gt;using&lt;/b&gt; &lt;b&gt;namespace&lt;/b&gt; boost::asio;

	ip::tcp::endpoint endpoint;
	std::string		status;
	std::string		maillength;
	std::istream	inbuffer ( m_streambuf.get() );
	std::string		msg;

	reenter ( &lt;b&gt;this&lt;/b&gt; ) {
restart:
		m_socket.reset( &lt;b&gt;new&lt;/b&gt; ip::tcp::socket(io_service) );

		&lt;b&gt;do&lt;/b&gt; {
&lt;span style=&#39;color:#006e28;&#39;&gt;#ifndef DEBUG&lt;/span&gt;
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 延时 60s&lt;/span&gt;&lt;/i&gt;
			_yield ::boost::delayedcallsec( io_service, &lt;span style=&#39;color:#b08000;&#39;&gt;60&lt;/span&gt;, boost::bind(*&lt;b&gt;this&lt;/b&gt;, ec, &lt;span style=&#39;color:#b08000;&#39;&gt;0&lt;/span&gt;) );
&lt;span style=&#39;color:#006e28;&#39;&gt;#endif&lt;/span&gt;

			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// dns 解析并连接.&lt;/span&gt;&lt;/i&gt;
 			_yield boost::async_avconnect(
 				boost::proxychain(io_service).add_proxy()(boost::proxy_tcp(*m_socket, ip::tcp::resolver::query(m_mailserver, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;110&amp;quot;&lt;/span&gt;))),
 				*&lt;b&gt;this&lt;/b&gt;);

			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 失败了延时 10s&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;if&lt;/b&gt; ( ec )
				_yield ::boost::delayedcallsec ( io_service, &lt;span style=&#39;color:#b08000;&#39;&gt;10&lt;/span&gt;, boost::bind(*&lt;b&gt;this&lt;/b&gt;, ec, &lt;span style=&#39;color:#b08000;&#39;&gt;0&lt;/span&gt;) );
		} &lt;b&gt;while&lt;/b&gt; ( ec ); &lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 尝试到连接成功为止!&lt;/span&gt;&lt;/i&gt;

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 好了，连接上了.&lt;/span&gt;&lt;/i&gt;
		m_streambuf.reset ( &lt;b&gt;new&lt;/b&gt; streambuf );
		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// &amp;quot;+OK QQMail POP3 Server v1.0 Service Ready(QQMail v2.0)&amp;quot;&lt;/span&gt;&lt;/i&gt;
		_yield	async_read_until ( *m_socket, *m_streambuf, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;, *&lt;b&gt;this&lt;/b&gt; );
		inbuffer &amp;gt;&amp;gt; status;

		&lt;b&gt;if&lt;/b&gt; ( status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;+OK&amp;quot;&lt;/span&gt; ) {
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 失败，重试.&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;goto&lt;/b&gt; restart;
		}

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 发送用户名.&lt;/span&gt;&lt;/i&gt;
		_yield m_socket-&amp;gt;async_write_some ( buffer ( std::string ( &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;user &amp;quot;&lt;/span&gt; ) + m_mailaddr + &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt; ), *&lt;b&gt;this&lt;/b&gt; );
		&lt;b&gt;if&lt;/b&gt;(ec) &lt;b&gt;goto&lt;/b&gt; restart;
		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 接受返回状态.&lt;/span&gt;&lt;/i&gt;
		m_streambuf.reset ( &lt;b&gt;new&lt;/b&gt; streambuf );
		_yield	async_read_until ( *m_socket, *m_streambuf, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;, *&lt;b&gt;this&lt;/b&gt; );
		inbuffer &amp;gt;&amp;gt; status;

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 解析是不是　OK.&lt;/span&gt;&lt;/i&gt;
		&lt;b&gt;if&lt;/b&gt; ( status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;+OK&amp;quot;&lt;/span&gt; ) {
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 失败，重试.&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;goto&lt;/b&gt; restart;
		}

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 发送密码.&lt;/span&gt;&lt;/i&gt;
		_yield m_socket-&amp;gt;async_write_some ( buffer ( std::string ( &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;pass &amp;quot;&lt;/span&gt; ) + m_passwd + &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt; ), *&lt;b&gt;this&lt;/b&gt; );
		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 接受返回状态.&lt;/span&gt;&lt;/i&gt;
		m_streambuf.reset ( &lt;b&gt;new&lt;/b&gt; streambuf );
		_yield	async_read_until ( *m_socket, *m_streambuf, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;, *&lt;b&gt;this&lt;/b&gt; );
		inbuffer &amp;gt;&amp;gt; status;

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 解析是不是　OK.&lt;/span&gt;&lt;/i&gt;
		&lt;b&gt;if&lt;/b&gt; ( status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;+OK&amp;quot;&lt;/span&gt; ) {
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 失败，重试.&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;goto&lt;/b&gt; restart;
		}

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 完成登录. 开始接收邮件.&lt;/span&gt;&lt;/i&gt;

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 发送　list 命令.&lt;/span&gt;&lt;/i&gt;
		_yield m_socket-&amp;gt;async_write_some ( buffer ( std::string ( &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;list&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt; ) ), *&lt;b&gt;this&lt;/b&gt; );
		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 接受返回的邮件.&lt;/span&gt;&lt;/i&gt;
		m_streambuf.reset ( &lt;b&gt;new&lt;/b&gt; streambuf );
		_yield	async_read_until ( *m_socket, *m_streambuf, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;, *&lt;b&gt;this&lt;/b&gt; );
		inbuffer &amp;gt;&amp;gt; status;

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 解析是不是　OK.&lt;/span&gt;&lt;/i&gt;
		&lt;b&gt;if&lt;/b&gt; ( status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;+OK&amp;quot;&lt;/span&gt; ) {
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 失败，重试.&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;goto&lt;/b&gt; restart;
		}

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 开始进入循环处理邮件.&lt;/span&gt;&lt;/i&gt;
		maillist.clear();
		_yield	m_socket-&amp;gt;async_read_some ( m_streambuf-&amp;gt;prepare ( &lt;span style=&#39;color:#b08000;&#39;&gt;8192&lt;/span&gt; ), *&lt;b&gt;this&lt;/b&gt; );
		m_streambuf-&amp;gt;commit ( length );

		&lt;b&gt;while&lt;/b&gt; ( status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;.&amp;quot;&lt;/span&gt; ) {
			maillength.clear();
			status.clear();
			inbuffer &amp;gt;&amp;gt; status;
			inbuffer &amp;gt;&amp;gt; maillength;

			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 把邮件的编号push到容器里.&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;if&lt;/b&gt; ( maillength.length() )
				maillist.push_back ( status );

			&lt;b&gt;if&lt;/b&gt; ( inbuffer.eof() &amp;amp;&amp;amp; status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;.&amp;quot;&lt;/span&gt; )
				_yield	m_socket-&amp;gt;async_read_some ( m_streambuf-&amp;gt;prepare ( &lt;span style=&#39;color:#b08000;&#39;&gt;8192&lt;/span&gt; ), *&lt;b&gt;this&lt;/b&gt; );
		}

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 获取邮件.&lt;/span&gt;&lt;/i&gt;
		&lt;b&gt;while&lt;/b&gt; ( !maillist.empty() ) {
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 发送　retr #number 命令.&lt;/span&gt;&lt;/i&gt;
			msg = boost::str ( boost::format ( &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;retr %s&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\r\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt; ) %  maillist[&lt;span style=&#39;color:#b08000;&#39;&gt;0&lt;/span&gt;] );
			_yield m_socket-&amp;gt;async_write_some ( buffer ( msg ), *&lt;b&gt;this&lt;/b&gt; );
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 获得　+OK&lt;/span&gt;&lt;/i&gt;
			m_streambuf.reset ( &lt;b&gt;new&lt;/b&gt; streambuf );
			_yield	async_read_until ( *m_socket, *m_streambuf, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;, *&lt;b&gt;this&lt;/b&gt; );
			inbuffer &amp;gt;&amp;gt; status;

			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 解析是不是　OK.&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;if&lt;/b&gt; ( status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;+OK&amp;quot;&lt;/span&gt; ) {
				&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 失败，重试.&lt;/span&gt;&lt;/i&gt;
				&lt;b&gt;goto&lt;/b&gt; restart;
			}

			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 获取邮件内容，邮件一单行的 . 结束.&lt;/span&gt;&lt;/i&gt;
			_yield	async_read_until ( *m_socket, *m_streambuf, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\r\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;.&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\r\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;, *&lt;b&gt;this&lt;/b&gt; );
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 然后将邮件内容给处理.&lt;/span&gt;&lt;/i&gt;
			process_mail ( inbuffer );
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 删除邮件啦.&lt;/span&gt;&lt;/i&gt;
			msg = boost::str ( boost::format ( &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;dele %s&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\r\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt; ) %  maillist[&lt;span style=&#39;color:#b08000;&#39;&gt;0&lt;/span&gt;] );
			_yield m_socket-&amp;gt;async_write_some ( buffer ( msg ), *&lt;b&gt;this&lt;/b&gt; );

			maillist.erase ( maillist.begin() );
			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 获得　+OK&lt;/span&gt;&lt;/i&gt;
			m_streambuf.reset ( &lt;b&gt;new&lt;/b&gt; streambuf );
			_yield	async_read_until ( *m_socket, *m_streambuf, &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt;, *&lt;b&gt;this&lt;/b&gt; );
			inbuffer &amp;gt;&amp;gt; status;

			&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 解析是不是　OK.&lt;/span&gt;&lt;/i&gt;
			&lt;b&gt;if&lt;/b&gt; ( status != &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;+OK&amp;quot;&lt;/span&gt; ) {
				&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 失败，但是并不是啥大问题.&lt;/span&gt;&lt;/i&gt;
				std::cout &amp;lt;&amp;lt; &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;deleting mail failed&amp;quot;&lt;/span&gt; &amp;lt;&amp;lt; std::endl;
				&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// but 如果是连接出问题那还是要重启的.&lt;/span&gt;&lt;/i&gt;
				&lt;b&gt;if&lt;/b&gt;(ec) &lt;b&gt;goto&lt;/b&gt; restart;
			}
		}

		&lt;i&gt;&lt;span style=&#39;color:#898887;&#39;&gt;// 处理完毕.&lt;/span&gt;&lt;/i&gt;
		_yield async_write ( *m_socket, buffer ( &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;quit&lt;/span&gt;&lt;span style=&#39;color:#924c9d;&#39;&gt;\n&lt;/span&gt;&lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;&lt;/span&gt; ), *&lt;b&gt;this&lt;/b&gt; );
		_yield ::boost::delayedcallsec ( io_service, &lt;span style=&#39;color:#b08000;&#39;&gt;1&lt;/span&gt;, boost::bind ( *&lt;b&gt;this&lt;/b&gt;, ec, &lt;span style=&#39;color:#b08000;&#39;&gt;0&lt;/span&gt; ) );
		&lt;b&gt;if&lt;/b&gt;(m_socket-&amp;gt;is_open())
			m_socket-&amp;gt;shutdown ( ip::tcp::socket::shutdown_both );
		_yield ::boost::delayedcallsec ( io_service, &lt;span style=&#39;color:#b08000;&#39;&gt;1&lt;/span&gt;, boost::bind ( *&lt;b&gt;this&lt;/b&gt;, ec, &lt;span style=&#39;color:#b08000;&#39;&gt;0&lt;/span&gt; ) );
		m_socket.reset();
		std::cout &amp;lt;&amp;lt; &lt;span style=&#39;color:#bf0303;&#39;&gt;&amp;quot;邮件处理完毕&amp;quot;&lt;/span&gt; &amp;lt;&amp;lt; std::endl;
		_yield ::boost::delayedcallsec ( io_service, &lt;span style=&#39;color:#b08000;&#39;&gt;30&lt;/span&gt;, boost::bind ( *&lt;b&gt;this&lt;/b&gt;, ec, &lt;span style=&#39;color:#b08000;&#39;&gt;0&lt;/span&gt; ) );
		&lt;b&gt;goto&lt;/b&gt; restart;
	}
}
&lt;/pre&gt;
&lt;!--  --&gt;
&lt;p&gt;这个代码，乍一看就是同步代码嘛！而事实上它是异步的&lt;/p&gt;</description>
    </item>
    <item>
      <title>Why ubuntu sucks and everyone should not use it</title>
      <link>https://microcai.org/2013/03/08/killubuntu.html</link>
      <pubDate>Fri, 08 Mar 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/03/08/killubuntu.html</guid>
      <description>&lt;p&gt;这篇文章早就应该发了，但是我太自私，只管自己躲在Gentoo的树阴下乘凉，不为那些在ubuntu的刀山祸害里挣扎的人提供援助。
所以，我觉得为他们提供无偿的援助——告诉他们，ubuntu很烂很烂。&lt;/p&gt;
&lt;p&gt;ubuntu的烂要分两个部分，其一是debian的烂，其二是ubuntu的烂。&lt;/p&gt;
&lt;p&gt;#　debian之烂&lt;/p&gt;
&lt;p&gt;debian的烂，体现在包管理器上，特别是debian特色的拆包习俗。&lt;/p&gt;
&lt;p&gt;debian的打包习俗有三大恶：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;拆包细&lt;/li&gt;
&lt;li&gt;乱改名&lt;/li&gt;
&lt;li&gt;版本旧&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;拆包过细，大大增加维护负担。虽然对用户来说看似节约了硬盘空间，安装更少的二进制数据，实际上包管理器的数据库变得更加庞大。&lt;/p&gt;
&lt;p&gt;乱改名这就是debian的原罪了。因为deb包本身的限制，无法在包里编制版本信息以允许相同的包的不同版本同时安装。只能采取将软件的版本作为后缀作为包名。比如　libXXX2 libXXX1 libXXX0
这样开发者在写依赖的时候，就需要知道具体后缀是0 还是1 还是2。非常麻烦。&lt;/p&gt;
&lt;p&gt;因为拆包细，写依赖就要写一堆，稍微不注意就少写依赖了。大大增加了打包人员的维护负担。&lt;/p&gt;
&lt;p&gt;乱改名和拆包结合起来，导致一些著名的软件，即便是使用他的本名你也安装不了。
比如 apt-get install git 是无法安装git的。因为　git 被拆包了，而且还改名了。到现在我也不知道如何安装git。&lt;/p&gt;
&lt;p&gt;debian 包以旧为荣耀，片面的认为旧就是稳定。&lt;/p&gt;
&lt;p&gt;debian的包，一个字旧。debian通常包含的是上游停止维护的版本。诶，你说上游停止维护的版本，稳定个鬼啊。&lt;/p&gt;
&lt;p&gt;可是　debian 不这么认为，debian 认为旧就是稳定。&lt;/p&gt;
&lt;h1 id=&#34;ubuntu自身之恶&#34;&gt;ubuntu自身之恶&lt;/h1&gt;
&lt;p&gt;除了&lt;em&gt;原原本本的继承&lt;/em&gt;了全部的debian之恶，ubuntu自身的恶就罄竹难书了。&lt;/p&gt;
&lt;p&gt;ubuntu喜欢控制，喜欢　fork　上游软件。然后自己定制。定制完了不回馈给上游。&lt;/p&gt;
&lt;p&gt;过了一年，ubuntu 又重新　fork　，因为自己　fork 的那个版本落后了，显然不能和上游竞争了。&lt;/p&gt;
&lt;p&gt;ubuntu想控制　gnome , 结果控制不了，就自己　fork 个　unity。先是　gtk 开发，然后失败，
然后　以compiz 插件开发，失败，然后又用　Qt　开发。
哥我还是会断定他继续失败。&lt;/p&gt;
&lt;p&gt;ubuntu一意孤行，一定要&lt;em&gt;故意&lt;/em&gt;创造和其他发行版不兼容的地方。其他发行版用　systemd , ubuntu一意孤行的使用upstart。故意创造不兼容的地方。&lt;/p&gt;
&lt;p&gt;TOBE ADD&lt;/p&gt;</description>
    </item>
    <item>
      <title>博客迁移到 github pages</title>
      <link>https://microcai.org/2013/02/02/blogtrans.html</link>
      <pubDate>Sat, 02 Feb 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/02/02/blogtrans.html</guid>
      <description>&lt;p&gt;越来越觉得花钱买一个 VPS 是个太浪费钱的事情了，而且也没那么多精力去维护服务器，于是将博客迁移到 github 就成了上上选择。&lt;/p&gt;
&lt;p&gt;现在终于完成迁移了，并且也开启了评论功能，真的是非常不错。可以使用 vim 编写博客了，这真的是太爽的事情了。&lt;/p&gt;
&lt;p&gt;目前的 url 是 &lt;a href=&#34;http://microcai.org&#34;&gt;http://microcai.org&lt;/a&gt;, 支持 RSS Feed, url是 &lt;a href=&#34;https://microcai.org/feed&#34;&gt;RSS Feed&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;每篇文章都可以使用评论功能哦！&lt;/p&gt;
&lt;p&gt;这真的是太爽了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>2012 年总结</title>
      <link>https://microcai.org/2013/01/31/2012sum.html</link>
      <pubDate>Thu, 31 Jan 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/01/31/2012sum.html</guid>
      <description>&lt;p&gt;过去一年里，啥事情没干。&lt;/p&gt;
&lt;p&gt;2012年来的时候，唔说，世界末日到来前不拼命工作。于是就每天宅家里啥也不做了。&lt;/p&gt;
&lt;p&gt;要说啥都没做也不对。&lt;/p&gt;
&lt;h3 id=&#34;乘宅在家里不用工作的机会把很久以前丢下的c重新学习了&#34;&gt;乘宅在家里不用工作的机会，把很久以前丢下的C++重新学习了。&lt;/h3&gt;
&lt;p&gt;重新学习C++是一个机缘巧合的事情，jack 一直是一个C++程序员，重度Boost粉丝。一直向我灌输boost。不过，我一直和云风一样，总是黑C++，说只用C开发。&lt;/p&gt;
&lt;p&gt;不过C++11的发布让我觉得有必要了解一下C++11。就算不用，我总要看别人的c++11代码的吧！本着这个目的，我仔细的看了c++老爸写的C++11 FAQ。&lt;/p&gt;
&lt;p&gt;新的c++11让我惊呼！ C++11乃神器也！&lt;/p&gt;
&lt;p&gt;我开始不黑C++了，我改变了对C++的坏印象。但是真正开始使用C++，与使用Boost可同一时间。
有一天，我读了ByVoid的博客，他推荐了一个叫rimeime的神级输入法。我被rimeime首页上那唯美的诗吸引了，认定rimeime作者一定是个大牛。当我编译rime的时候，发现rime居然是使用Boost开发的。rimeime专注于输入法方面算法，只字不提开发中的啥数据结构啊之类的，让我这个整天活在C世界的乡巴佬汗颜。我过多的思考底层了。是个毛病，该改！我意思到，软件开发就应该专注于这个专业领域的东西，不要被C语言带来的计算机原理模糊掉自己的方向。和 jack 讨论了这个问题，他也认为当下的编程语言，都过分的让程序员考虑计算机的内部原理了。而能让不懂编程的用户快速的开发出程序的语言，都死了。（VB 泪流满面）
于是我再一次拿起C++的时候，自己打算试一试，再加上jack的鼓吹，终于开始使用Boost了。
Boost 真乃神器也~ 有种相见恨晚的感觉。&lt;/p&gt;
&lt;h3 id=&#34;llvm是个好东西于是借着编写一个qbasic编译器的功夫学习了一下llvm&#34;&gt;LLVM是个好东西，于是借着编写一个QBASIC编译器的功夫学习了一下LLVM&lt;/h3&gt;
&lt;p&gt;很早的时候，我就想写一个编译器。一直认为编译器是一个很高难度的东西。于是我选择了一个简单的语言：QBASIC作为我的目标。经过一个星期的编译原理方面的学习，终于靠着llvm这个大山写出了一个编译器，哦也，感觉非常不错。&lt;/p&gt;
&lt;h3 id=&#34;avplayerorg-社区创立&#34;&gt;avplayer.org 社区创立。&lt;/h3&gt;
&lt;p&gt;avplayer是jack编写的一个p2p播放器。我有幸参与了开发，并做了Linux版本的移植工作。
之后加入了jack建立的一个QQ群。因为 Linux 下QQ并不方便使用。于是我打算开发一个能将 QQ和IRC结合起来的机器人。这样我就可以在 IRC 上参与群的讨论。 这个想法的直接结果就是导致 qqbot 的诞生。然后jack和我感觉应该创立一个社区，吸引国内优秀的程序员加入。于是建立了 avplayer.org 社区，并将 qqbot 改名为 avbot ，和 avplayer 一道成为 avplayer.org 社区项目。成立后，hyq 迅速的贡献了自己开发的 avsocks 软件，成为社区的三驾马车。 avsocks 原由go语言开发，我迅速的将其用 boost 重构。avsocks 目前可是最受欢迎的项目，呵呵。&lt;/p&gt;</description>
    </item>
    <item>
      <title>avplayer 开源软件组织成立，域名  avplayer.org</title>
      <link>https://microcai.org/2013/01/01/avplayer.html</link>
      <pubDate>Tue, 01 Jan 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/01/01/avplayer.html</guid>
      <description>&lt;h1 id=&#34;avplayerorg-项目组成立了&#34;&gt;avplayer.org 项目组成立了。&lt;/h1&gt;
&lt;p&gt;avplayer 的宗旨是开发易于使用的跨平台 AV播放器框架。avplayer自带一个用 AV播放器框架写的AVPLAYER播放器。 依托于 AVPLAYER本组织还开发了用于成员沟通的 AVBOT (原 QQBOT)。 AVBOT 实现了 QQ/IRC/XMPP的互通。&lt;/p&gt;
&lt;p&gt;为了更科学的上网，本群再次发力，开发了 AVSOCKS 科学操长城软件。&lt;/p&gt;
&lt;p&gt;当然， 所有的代码都在 &lt;a href=&#34;https://github.com/avplayer&#34;&gt;https://github.com/avplayer&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;项目首页 &lt;a href=&#34;http://avplayer.org&#34;&gt;http://avplayer.org&lt;/a&gt;&lt;/p&gt;
&lt;h3 id=&#34;如何加入&#34;&gt;如何加入？&lt;/h3&gt;
&lt;p&gt;首先要会 C++。不会也没关系，进来一起学习 AV ,学习的过程中就会 C++了。使用 BOOST 神器加速。多少AV都不怕。来组织的人，都嗑 BOOST 上瘾了，相信你加入后也会被 BOOST 征服的。
如何加入？&lt;/p&gt;
&lt;p&gt;简单，加入 QQ群 3597082 即可。 没有 QQ ? Linuxer ? 没关系，咱不是用 AVBOT 么！ 进入 #avplayer @ irc.freenode.net 一样可以参与聊天。&lt;/p&gt;
&lt;p&gt;哦？不会 IRC ? 还好有了 AVBOT, 加入 XMPP 聊天室 &lt;a href=&#34;mailto:avplayer@im.linuxapp.org&#34;&gt;avplayer@im.linuxapp.org&lt;/a&gt; 即可！&lt;/p&gt;</description>
    </item>
    <item>
      <title>python是个渣语言</title>
      <link>https://microcai.org/2012/12/25/whypythonbad.html</link>
      <pubDate>Tue, 25 Dec 2012 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2012/12/25/whypythonbad.html</guid>
      <description>&lt;p&gt;一直以来我都表达 python 是个糟糕语言的观点，但是没有深入的解释。&lt;/p&gt;
&lt;p&gt;计算机一直都是“工具”，意味着我们是拿它干活的，也就是所谓的提高生产力。&lt;/p&gt;
&lt;p&gt;指挥计算机干活的重要工具就是编程语言。计算机并不是训练来干活的，是编程来干活的。编程语言的效率有2个指标：编写干活指南的效率和机器人执行的效率。&lt;/p&gt;
&lt;p&gt;在人力成本低于硬件的时候，人追捧的是执行效率。&lt;/p&gt;
&lt;p&gt;人力成本越来越高的时候，人开始追求编程的效率。&lt;/p&gt;
&lt;p&gt;人自然是希望一个语言能两头兼顾。可惜的是 python非但没有带来执行效率（这是python不追求的，所以姑且不算缺点），连它拼命牺牲执行效率希望换来的开发效率事实上也一点没有。&lt;/p&gt;
&lt;p&gt;执行效率：首先，执行效率和语言本身高级不高级是没有任何关系的。执行效率的高低只关系到冗余操作的多寡。这也是“优化”的基础，去除冗余操作。&lt;/p&gt;
&lt;p&gt;冗余操作的多寡通常有3个因素影响到：1 编译器的效率  2 程序员的水平 3 语言本身的累赘&lt;/p&gt;
&lt;p&gt;但是衡量一个语言本身效率的，事实上应该是最后一个 &amp;ldquo;语言本身的累赘&amp;rdquo;，这个才是编译器永远无法改进的，程序员水平再高也无能为力的。&lt;/p&gt;
&lt;p&gt;不幸的是，python是一个本身的累赘非常多的语言。而累赘最少的语言，应该算是C++语言了。所有C++用到的功能，没有一个是可以在别的语言用更低的代价实现的。当然，有的语言压根就没有C++提供的功能，必须自己模拟。模拟的代价和C++提供的是一样的，水平不够的人来模拟只能获得更烂的结果。&lt;/p&gt;
&lt;p&gt;当然 ，python是个高级语言，语法糖多点，性能烂就接受一下吧！毕竟开发效率高呢（？）&lt;/p&gt;
&lt;p&gt;接下来我们说编程的效率。编程效率主要是受5个因素影响：语法是否自然，语义是否凝炼，文档或者或教程多不多，库是不是丰富，开发环境好不好。不用说python的文档还是很多的，但是显然没有c++多。各种粗制滥造的c++教程铺天盖地，算了，这是c++的坏处。误人子弟的教程太多。库当然是C++最丰富了。python还面临着 python3 和 python2 的分裂。&lt;/p&gt;
&lt;p&gt;开发环境和库一直是C++的优势。不用说 Visual C++这种重量级公司出的IDE ，还有 kdevelop , eclipse CDT 这些免费开源的IDE。自动完成和代码提示让你写代码的时候非常轻松。相比之下 ， python 就没有好的IDE了。&lt;/p&gt;
&lt;p&gt;当然，接下来是程序员最关心的，语法是否自然，语义是否凝炼。python 的语义自然是很多的，一条语句能相当于写几千行 C 代码。这也是人常说的，语法糖多。可惜的是，C++一样有高级语法糖，而且代价很低！比python低太多了。在这一点上，python没有优势，只有劣质。python的语法糖是以牺牲性能换来的，而C++在不损失性能的同时提供了语法糖。&lt;/p&gt;
&lt;p&gt;至于语法自然不，仁者见仁智者见智了。对于大多数C学过来的人来说， 自然是C++的语法简单。当然，前提是不使用模板这种高级货。真的用模板的话，模板是属于用起来简单，写起来难的语法糖。我们自然可以选择把困难留给 boost，快乐留给自己。所以这点上 C++没有输。何况python还不支持模板。&lt;/p&gt;
&lt;p&gt;那么开发效率到底是 C++高还是 python呢？&lt;/p&gt;
&lt;p&gt;差不多！&lt;/p&gt;
&lt;p&gt;那执行效率呢？&lt;/p&gt;
&lt;p&gt;C++和python不是一个档次的，没法比。&lt;/p&gt;
&lt;p&gt;好了，单从这点已经 python 完败。不过我想说的还不是这个。&lt;/p&gt;
&lt;p&gt;如果真的有语言像python那样慢，我觉得对得起它的性能的，就必须拿出像样的功能，这个功能包括&lt;/p&gt;
&lt;p&gt;语言级的并行能力，语言级的多进程能力 （等等，这不就是shell么！），语言级的SIMD能力（语言级的矩阵运算支持）&lt;/p&gt;
&lt;p&gt;语言级的复杂数学公式计算能力  ，内置的标准各种算法（STL笑而不语，不过我要的还不止STL），描述性语义（而非指令性语义）&lt;/p&gt;
&lt;p&gt;我要求的这些，是高级语言需要具备的，而 python 统统没有，连 shell 都能占上一些！&lt;/p&gt;</description>
    </item>
    <item>
      <title>内存管理随笔</title>
      <link>https://microcai.org/2012/10/31/mm.html</link>
      <pubDate>Wed, 31 Oct 2012 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2012/10/31/mm.html</guid>
      <description>&lt;h3 id=&#34;思考一&#34;&gt;思考一：&lt;/h3&gt;
&lt;p&gt;任何一个程序，只要不是 helloworld 那样的简单程序，必然会用到内存管理。内存管理是写程序不可避免的过程。C程序员最大的恶魔就是野指针和内存泄漏。这是每个C程序员的噩梦。C++继承了C的缺陷，基本上半斤八两。而且C++还可以自由重载new操作符，给内存管理更加重了复杂性。
我常常在想，写BASH脚本的时候，我们有管理过内存么？即便是java那样的语言，内存管理也是后台进行的，并不是可避免的，俗称GC。可是写脚本的时候，真的完全没用内存管理方面的困扰。&lt;/p&gt;
&lt;p&gt;到底是哪里出了问题呢？到底为何脚本就不用管理内存？&lt;/p&gt;
&lt;h3 id=&#34;思考二&#34;&gt;思考二：&lt;/h3&gt;
&lt;p&gt;能不能完全不依靠malloc/free new/delete 编写出一个 c/c++程序呢？&lt;/p&gt;
&lt;p&gt;结果是显然的，能！&lt;/p&gt;
&lt;p&gt;但是只有对 hello world 那样的程序才有用。最近的一项小随笔项目证实了我的想法 &lt;a href=&#34;https://github.com/microcai/hm&#34;&gt;https://github.com/microcai/hm&lt;/a&gt; 。在这个程序里，我没用使用任何 malloc/free new/delete 来管理内存。&lt;/p&gt;
&lt;p&gt;为何这个程序可以不用内存管理呢？ 于是在另一个随笔项目里，我依然使用了内存管理，虽然是智能指针自动管理的，但是毕竟使用了 new 操作 &lt;a href=&#34;https://github.com/microcai/googleproxy&#34;&gt;https://github.com/microcai/googleproxy&lt;/a&gt; 。我在想，凭啥这个程序就必须使用 new 了？&lt;/p&gt;
&lt;h3 id=&#34;思考三&#34;&gt;思考三：&lt;/h3&gt;
&lt;p&gt;程序，说到底就是一个状态机。在 hm 程序里，我采用的是“过程化”编程，外加同步多进程的IO模型。在 googleproxy 程序里，使用的是单线程异步IO的模型。&lt;/p&gt;
&lt;p&gt;hm里，状态机的状态就是进程的状态。一步一步执行下去，状态随之切换。cpu执行到哪一行，哪一行就是当前状态。&lt;/p&gt;
&lt;p&gt;googleproxy里，情况有了变化，因为使用了异步，所有的状态变化都是围绕一个中心进行的： boost::io_service::run() 。 在 run() 里，通过回调来通知状态的变化。也就是说，cpu执行到哪个回调，哪个就是当前状态。
区别是什么：&lt;/p&gt;
&lt;p&gt;在不同的状态之间，我们有数据要共享！ hm 多使用局部变量，不同的状态需要共享数据，通常也处于同一代码层级！可以直接引用需要的数据！&lt;/p&gt;
&lt;p&gt;googleproxy 里，不同的状态之间，是不同的 run() 操作的回调，需要共享数据，但是上一个状态的局部变量已经消失！上一个状态的局部变量已经消失！
要跨栈域引用共享数据，唯一的办法就是将数据创建在堆上！&lt;/p&gt;
&lt;p&gt;简单的来说，在一个程序里，所有代码的执行路径可以归纳为从 main() 开始的一个调用树。一个函数只能引用本层和上层的局部变量，无法引用子层和兄弟层和兄弟的子层的局部变量。因为这些地方的变量都是不存在的呀！&lt;/p&gt;
&lt;p&gt;所以，只能将共享数据创建在堆上。这样才能跨过调用树的生存周期！&lt;/p&gt;
&lt;p&gt;这也是唯一需要堆管理的理由。&lt;/p&gt;
&lt;p&gt;如果一个变量要进入函数的时候创建在堆上，退出的时候释放，通常的做法其实就是使用栈变量，或者是使用可变长度的stl容器。&lt;/p&gt;
&lt;p&gt;如果返回值是对象，也不要使用指针了，直接返回对象吧！别担心临时对象拷贝开销了。&lt;/p&gt;
&lt;p&gt;只有当跨栈域共享对象的时候，才考虑使用堆吧！
记住：即便如此，也不要使用裸指针。裸指针只用来进行直接内存访问（底层编程的时候），千万别用来引用对象。使用智能指针吧！放弃对象的拷贝开销的担心吧！ 那几百个周期的拷贝操作比 new/delete 的内存管理代码的开销相比，还是低太多里。何况有了 c++11 的 Move 语义，很多时候已经没用拷贝开销里。&lt;/p&gt;
&lt;p&gt;放心大胆的脚本化C++程序吧！ 实在需要跨栈共享数据的时候，使用 shared_ptr 引用吧！&lt;/p&gt;</description>
    </item>
    <item>
      <title>C&#43;&#43; 王者归来</title>
      <link>https://microcai.org/2012/10/12/cppreturn.html</link>
      <pubDate>Fri, 12 Oct 2012 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2012/10/12/cppreturn.html</guid>
      <description>&lt;p&gt;曾几何时，学会了C语言。安装了VC6这个神叉IDE。&lt;/p&gt;
&lt;p&gt;然后被迫开始CPP路程。由于C++兼容C，所以一直在以C的方式写C++。然后慢慢的开始学写C++代码。写C++代码是从MFC开始的。慢慢的，我学会了用class，感觉是个比struct好用的多的结构体。再慢慢的，我学会了继承，还有&amp;hellip; 多重继承。&lt;/p&gt;
&lt;p&gt;MFC 就是我的导师。开始不停的向MFC学习。既然用了c++的继承，就认识到了继承的陷阱。继承后，构造函数和构析函数的执行次序，等等。还有虚继承后的各种问题和陷阱。&lt;/p&gt;
&lt;p&gt;一一去了解。&lt;/p&gt;
&lt;p&gt;在程序结构方面，开始向 MFC 看齐。喜欢把任何操作都包装到class里。设计class的时候，开始过度设计。总考虑到某天我会需要继承它。说不定还需要多重继承。等等。明明已经设计好class，却喜欢继续添加功能。永远用不到的功能。只因为我“未来可能需要在别的程序里用，可能需要继承它。”&lt;/p&gt;
&lt;p&gt;任何一个程序，我都为它设计对象，全局的程序对象又有子对象，子又有子，子子孙孙无穷尽也～&lt;/p&gt;
&lt;p&gt;成员变量一多，构造函数里成员变量初始化代码就变多。然后设计构造函数重载。写更多的用不到的构造函数。
我没有意识到，我已经犯了过度设计的毛病了&lt;/p&gt;
&lt;p&gt;而c++另一个强大的功能“模板”我却一无所知。当我发现了c++还有模板功能的时候，我只是简单的尝试了一下，发现模板无法在VC下很好的被自动完成。又听说模板会导致代码膨胀，诸如此类。我只小用一下模板。就丢弃了模板。继续我过度设计的c++之路。&lt;/p&gt;
&lt;p&gt;&lt;font color=&#34;red&#34;&gt; 某一天，我开始Linux之路。  &lt;/font&gt;&lt;/p&gt;
&lt;p&gt;当我开始写出第一个GTK程序的时候，发现了C之美。C可以写出和C++一样的对象代码。而且没有了 C++的许多陷阱。&lt;/p&gt;
&lt;p&gt;也正因为C，我开始摒弃了过度设计。所设计的API皆以现阶段够用为限。未来怎么样，未来再添加好了。没有了c++的包袱，再也不设计class了。都是简单的函数。函数完成一个“过程”。而不再是操作一个“对象”。让我把精力放到了“过程”本身，而不会再去设计“漂亮的对象”。&lt;/p&gt;
&lt;p&gt;之后阅读到了Linus对C++的一篇讽刺邮件。对比自身，多多感触。c++确实是个容易写出糟糕代码的语言。&lt;/p&gt;
&lt;p&gt;从此发誓不再用c++，只以C写代码。&lt;/p&gt;
&lt;p&gt;再一次拾起C++，是因为c++11的发布，有了一些新的语法糖。我虽然不再打算写c++代码，但是没打算不再读别人的c++代码。如果别人用c++11写了新的代码，我确看不懂，不是损失是什么。我决定看一看c++11。&lt;/p&gt;
&lt;p&gt;c++11最令我着迷的新特性就是lambda。还有新的for语法。当然，boost::bind 和 boost::function 进入了 std。成为的标准的一部分。我对 std::function 的印象只限于“更好的函数指针替代”。&lt;/p&gt;
&lt;p&gt;lambda 一用，发现非常不错。好多麻烦的 static 函数都可以被匿名的 lambda取代了。我喜欢这种让名称空间更干净的感觉。&lt;/p&gt;
&lt;p&gt;我开始纠结lambda了。动摇了。如果只用c++兼容C的那部分，然后lambda，就是带lambda的C嘛！这样自欺欺人的开始用C++。&lt;/p&gt;
&lt;p&gt;参与了朋友的一个小项目。他是个重度c++粉。但是因为他的关系，我开始真正的拿起了boost。他说，没有boost他就没办法写代码。&lt;/p&gt;
&lt;p&gt;这里有个小插曲，我在Linux下一直用eclipse编程，但是也因为boost把eclipse搞崩溃了，重拾了KDevelop。结果发现KDevelop已经不再是我第一次使用的时候（Kdevelop 3.？ 的样子，好多年前的尝试。）那样使用正则匹配的自动完成了，真正的和eclipse一样是通过语法解析获得的自动完成列表。这导致KDevelop的自动完成功能异常强大，和 eclipse一样智能。所不同的是，eclipse在解析boost的代码的时候会时不时的崩溃，而且eclipse花了很久很久的假死状态解析boost头文件。毕竟是java开发的，速度还是不行啊！但是KDevelop完成boost头文件的解析只需要几秒钟。第一次打开cpp文件的时候，KDevelop在后台花了及秒钟解析了boost头文件，然后打代码的时候boost的所有功能就全部都能提示出来了。和eclipse一样的自动完成，速度快了几百倍，我马上切换到了KDevelop，并卸载了eclipse。&lt;/p&gt;
&lt;p&gt;其实之前也尝试过boost，都被假死状态的eclipse弄怕了。所以关了eclipse的index功能没了boost的语法提升瞎写过。&lt;/p&gt;
&lt;p&gt;但是换到KDevelop后那畅快淋淋的感觉，打出 boost:: 后那完善的提示，我马上开始全身心的试用boost。&lt;/p&gt;
&lt;p&gt;就是这一试用，让我重回了c++的怀抱。重回c++后，我发现了c++正确的用法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class只能作为基础，构建比int/long/char要高级点的对象。绝不能用来构造程序本身。像MFC那样搞个 CMyApp 绝对是对c++的侮辱。也就是说，程序主体仍是C语言式的。

可以用class构建string，构建bigint，用重载为bigint编写大数乘法... 这才是 class 和运算符重载的意义。绝对不能肆意滥用。

必要的时候编写模板代替宏。

模板更好的用法是使用boost这样现成的模板库。

设计回调函数，使用 std::function/boost::function。这样可以使用 std::bind/boost::bind 绑定任意多的参数给回调函数用，避免C里的void*user_data设计。

虚回调函数绝对是个傻逼设计。迫使用户使用继承并进行虚成员函数重载。
&lt;/code&gt;&lt;/pre&gt;</description>
    </item>
    <item>
      <title>善待笔记本，启用intel集显的节能模式</title>
      <link>https://microcai.org/2011/11/16/intelgpurc6.html</link>
      <pubDate>Wed, 16 Nov 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/11/16/intelgpurc6.html</guid>
      <description>&lt;p&gt;在 XP 下用的时候，用计量插座，空闲功耗大概在 13W ~ 14W 之间。&lt;/p&gt;
&lt;p&gt;在 Gentoo 下用的时候，空闲功耗也在 20W 之上。&lt;/p&gt;
&lt;p&gt;很头痛。&lt;/p&gt;
&lt;p&gt;CPU 的节能已经打开，一直在 800M 最低频率运行呢！&lt;/p&gt;
&lt;p&gt;恩，应该是 GPU 费电啊～～～ 有什么办法能让 intel 的 GPU 工作在节能模式呢？&lt;/p&gt;
&lt;p&gt;答案是添加隐含的内核引导参数&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;i915.lvds_downclock=1 i915.i915_enable_fbc=1 i915.i915_enable_rc6=1 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;神奇的参数。&lt;/p&gt;
&lt;p&gt;现在 Gentoo 空闲下来的时候，笔记本也是 13W ~ 14W 的功耗了。哦也 ～～ CPU 也没那么热了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>i7 拯救了 Gentoo</title>
      <link>https://microcai.org/2011/11/11/i7savedgentoo.html</link>
      <pubDate>Fri, 11 Nov 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/11/11/i7savedgentoo.html</guid>
      <description>&lt;p&gt;好多年以前，我开始了 Linux 之旅。&lt;/p&gt;
&lt;p&gt;我频繁的切换发行版，从 RedFlag 5 到 RedFlag 6 再到 ubuntu 8.10 马上又切到 Fedora 8 然后是 9 10 , 期间又重回 RedFlag 7 过，间或也使用过 debian 和 puppy。&lt;/p&gt;
&lt;p&gt;如此频繁的切换发行版，只不过是我觉得它们都没有满足我的要求。我不停的切换，企图寻找到一个可以一劳永逸的满足我的需求的系统。 我不停的搜索着，尝试着。&lt;/p&gt;
&lt;p&gt;直到有一天，我发现了 Gentoo 。&lt;/p&gt;
&lt;p&gt;那个时候我已经厌倦了 Fedora . 不停的重装，只是为了升级。尝试过 upgrade , 只不过比不得重装快活。也有很多错误，不如重装干脆。&lt;/p&gt;
&lt;p&gt;我实在是厌倦了每6个月重装一下系统，只是为了升级。我也厌倦了每次重装好系统之后都要开始好几天的清理工作，把不需要的东西删除掉，再把需要的软件又重装一次。&lt;/p&gt;
&lt;p&gt;直到我发现了 Gentoo .&lt;/p&gt;
&lt;p&gt;经过漫长的编译后，我有了一个可以启动的 Gentoo 系统。但是没有 X , 没有gnome，没有 firefox . 啥都没有。&lt;/p&gt;
&lt;p&gt;编译 firefox 前我需要 DE ，我选择 gnome, 编译 gnome 前我需要 X . 为了编译 firefox , 5 百多个软件需要被编译。&lt;/p&gt;
&lt;p&gt;又是一个 overnight 编译。&lt;/p&gt;
&lt;p&gt;第3天早上，打开显示器查看的时候终于编译好了。期间因为编译错误中断过几次，手工排除了一些错误，继续编译。不过总的来说，一个可以上网的环境就编译好了。&lt;/p&gt;
&lt;p&gt;接下来是更多的编译。因为我需要的一切都没有安装。编译 编译 编译 编译 编译 从此成了吃饭后的重要工作。&lt;/p&gt;</description>
    </item>
    <item>
      <title>别了 AMD . 来了 Intel.</title>
      <link>https://microcai.org/2011/10/25/88amd.html</link>
      <pubDate>Tue, 25 Oct 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/10/25/88amd.html</guid>
      <description>&lt;p&gt;刚开始接触到电脑的时候，正是 K8 无限风光， P4 高频低能的时候。那个时候起心里就有了 amd 的 U 便宜又好，低频高能的种子了。&lt;/p&gt;
&lt;p&gt;到自己 DIY 的时候，就买了 AMD 的 U . NVIDIA 的芯片组。 那个时候扣肉还没有出， AMD 的 K8 余光依旧，K10 风头正好。AMD 率先推出双核，intel 还是伪双核, etc .&lt;/p&gt;
&lt;p&gt;当时买的是入门双核 4200+ . 配合 MCP61S 的主板。外加 DDR2-800 1G*2 内存。&lt;/p&gt;
&lt;p&gt;因为配置起来就是为了玩 Linux 的，所以特地买的 NVIDIA 显卡。 事实证明，所有的显卡问题统统都没有让我碰到。先见之明啊&lt;/p&gt;
&lt;p&gt;这个配置就伴随着我3年，直到去年年底，一次刷主板不小心给刷成砖头了。悲剧。&lt;/p&gt;
&lt;p&gt;买个新主板去咯～&lt;/p&gt;
&lt;p&gt;结果，这一买新主板就几乎是大换血。那个时候 AMD 已经升级到了 AM3 接口的 U 了。而内存也已经主流 DDR3 了。&lt;/p&gt;
&lt;p&gt;这次买主板，自然就干脆全换了。 U 升级到了 AMD x2 215 @2.7G , 内存加到 4G . 由于偏爱小机箱，MATX 主板可挑选余地依旧不多。还是 MCP61P 主板。 （MCP61 的生命力啊！）&lt;/p&gt;</description>
    </item>
    <item>
      <title>给老婆的 F41M (注意后面有个M ... M M M M (都是回音)) 升级到 T9300 CPU 和 4G 内存</title>
      <link>https://microcai.org/2011/10/24/kiki.html</link>
      <pubDate>Mon, 24 Oct 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/10/24/kiki.html</guid>
      <description>&lt;p&gt;上回说道，老婆大人换到 ubuntu 后突然觉得电脑好慢好慢 。。。 。。。 慢到蜗牛都吃到葡萄了这 Unity 界面还没显示出来。&lt;/p&gt;
&lt;p&gt;嗯嗯，言归正传。&lt;/p&gt;
&lt;p&gt;老婆大人的电脑是 08 年买的，好早（老）保护的比较好，外观还很新。不过，鲜丽的外表掩饰不了那落后的奔腾的芯。&lt;/p&gt;
&lt;p&gt;废话不说，晒一下配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU: T2330 
内存: 1G 
硬盘: 160G@5400RPM@50-30MB/s 
芯片组：GL960 (没错，就是那个坑爹的960) 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这台老本的升级是在今年3月的时候开始的。
那个时候，我给自己的EeePC买了一个500G的希捷最快笔记本硬盘。淘汰下来的250G希捷硬盘自然就交给老婆的电脑进行消化咯。&lt;/p&gt;
&lt;p&gt;电脑速度给力提升。windows 评分里硬盘速度已经是当中的最高分了。&lt;/p&gt;
&lt;p&gt;之后我给 EeePC 换到 2G 内存，剩下的 1G 内存就给老婆用，组成了双通道。内存性能又提升了1分。&lt;/p&gt;
&lt;p&gt;然后，然后就是上一篇博文里说的情况了，电脑太不给力了！&lt;/p&gt;
&lt;p&gt;问得频道里老同志后，得知我应该去买 T7500 升级。&lt;/p&gt;
&lt;p&gt;然后打算买T7500的时候，从论坛里搜得有人把 F41 升级到了 T9300 &amp;hellip; &amp;hellip; 楼下回复得知 GM965主板最高支持 T9500 CPU. （这个时候还不知道 F41M是阉割过的。）&lt;/p&gt;
&lt;p&gt;哈哈！升级！ 淘宝上找了个本地卖家买 T9500（他有 ES 版，特别便宜啊） . 结果没货，但是有 T9300 . 恩，也就差一点，也行。然后他就上门服务来了。&lt;/p&gt;
&lt;p&gt;结果很悲剧。上了 T9300 , 能开机，进入系统很正常。也识别出了 CPU 的型号。可惜，正常了一分钟后，系统就出问题了。USB口失灵，无线没信号。屏幕莫名其妙的闪烁（Aero 消失又回来）。&lt;/p&gt;
&lt;p&gt;什么情况？？？？？？&lt;/p&gt;
&lt;p&gt;过热？ 重新涂抹硅脂试试。&lt;/p&gt;
&lt;p&gt;一样。&lt;/p&gt;</description>
    </item>
    <item>
      <title>原来 Linux 已经慢到这种地步了啊</title>
      <link>https://microcai.org/2011/10/20/linuxslow.html</link>
      <pubDate>Thu, 20 Oct 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/10/20/linuxslow.html</guid>
      <description>&lt;p&gt;因为特别喜欢 Gentoo , 所以自从2年前的一次偶然，我用上了 Gentoo 后就在也没有换过系统。&lt;/p&gt;
&lt;p&gt;Gentoo 的好处非常多，多到数不清。&lt;/p&gt;
&lt;p&gt;连老婆大人的系统我都给折腾成了 Gentoo.&lt;/p&gt;
&lt;p&gt;不过，由于疏于维护，老婆大人的 Gentoo 出了些许毛病，主要是 Gnome 3 太不稳定，太不给力，太容易崩溃。&lt;/p&gt;
&lt;p&gt;老婆坚持下，换了 Ubuntu&lt;/p&gt;
&lt;p&gt;一直以为老婆大人的破硬件不给力，所以进 Gentoo 都得花个30+s 。好慢。&lt;/p&gt;
&lt;p&gt;用了 Ubuntu 我才知道，原来电脑可以这么慢！原来 Linux 已经慢到这种地步了！ 居然要 1min多才能进系统。然后再卡个十几秒才能用。&lt;/p&gt;
&lt;p&gt;！！！！！！！&lt;/p&gt;
&lt;p&gt;不是 Gentoo 太慢，而是我对系统性能要求太高，而是硬件太不给力！&lt;/p&gt;
&lt;p&gt;换硬件+切回Gentoo才是给力的选择。&lt;/p&gt;
&lt;p&gt;于是我开始了艰难的折腾之路，把笔记本从 CPU 到主板到内存到光驱全换了个遍。请留意下回分解。&lt;/p&gt;</description>
    </item>
    <item>
      <title>从 RedFlag 到 Gentoo, 多少年，一瞬间</title>
      <link>https://microcai.org/2011/07/20/fromredflagtogentoo.html</link>
      <pubDate>Wed, 20 Jul 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/07/20/fromredflagtogentoo.html</guid>
      <description>&lt;p&gt;很久很久以前，在我还认为米国人生活在水生火热之中的时候，我认识了 Linux , 于是在买了电脑前就去亚马逊买了 Fedora 8 的DVD &amp;hellip;&lt;/p&gt;
&lt;p&gt;等我的电脑 DIY 好了，我立刻就安装了 Fedora 8&lt;/p&gt;
&lt;p&gt;但是&amp;hellip; 似乎连个 mp3 都播放不了。 就在我寻找如何解决的时候，我发现了 RedFlag 6。&lt;/p&gt;
&lt;p&gt;于是，我试试看的态度安装上了 RedFlag, 呵呵，果然 mp3 啊，rmvb 什么的，都不是问题了。非常喜欢。而且自带的 KDE3 界面也非常 windows like .. 用的多熟悉啊！&lt;/p&gt;
&lt;p&gt;就这样喜欢上了 Linux 桌面。&lt;/p&gt;
&lt;p&gt;RedFlag 是那种大而全的发行版，把什么软件都往里面装。2个 CD 安装好后就和安装了番茄花园一样齐全了。 也不缺什么了。当然，如果什么软件没有带的话，还是要自己 做 ./configure 族的。&lt;/p&gt;
&lt;p&gt;这就和盗版 Windows 很像了。基本系统很大，常用软件都有，但是，要别的 app , 自己装去。&lt;/p&gt;
&lt;p&gt;不过 ，自己安装软件的时候比较少，所以我开始了半年的 RedFlag 征途&lt;/p&gt;
&lt;p&gt;后来，买了个摄像头。&lt;/p&gt;
&lt;p&gt;居然不知道用什么软件能使用摄像头 &amp;hellip; 还好没几天 Fedora 10 发布了。恩，里面有个叫 cheese 的软件可以用摄像头。&lt;/p&gt;
&lt;p&gt;RedFlag 里居然没有！&lt;/p&gt;
&lt;p&gt;于是我又开始做 ./configure &amp;amp;&amp;amp; make &amp;amp;&amp;amp; make install 族了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>定期发布 Release 不适合现代 Linux Distro</title>
      <link>https://microcai.org/2011/07/02/rollingreleaseisbetter.html</link>
      <pubDate>Sat, 02 Jul 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/07/02/rollingreleaseisbetter.html</guid>
      <description>&lt;p&gt;我想说，定期发布 Release 这种模式已经过时了！&lt;/p&gt;
&lt;p&gt;想想看 ubuntu 的 LTS 版本是如何在生命周期结束前就过时的吧！&lt;/p&gt;
&lt;p&gt;上一个 ubuntu TLS 版本，居然不包含 gtk3 , 如果要实用一点，基本上要添加一 大堆的 PPA.
而使用 PPA 基本上就和 TLS 的理念背道而驰了。&lt;/p&gt;
&lt;p&gt;dabian 这样的发行版，基本上的发布前就过时了。&lt;/p&gt;
&lt;p&gt;! 没错。 glibc, core-utils 这样的软件需要稳定！&lt;/p&gt;
&lt;p&gt;那么用旧一点的版本确实是比较稳定.&lt;/p&gt;
&lt;p&gt;问题是，gnome KDE 这样的软件，反而是新版本比较稳定。&lt;/p&gt;
&lt;p&gt;这样 TLS 这种追求旧 版本的发行版，其实除了基础包，别的包都是在使用的不稳定版本，反而美其名 曰：stable.&lt;/p&gt;
&lt;p&gt;最明显的例子， KDE 4.6 发布的时候，是 KDE 最稳定的时候，这个时候 debian 里刚刚有 KDE4 &amp;hellip;. 最不稳定的 KDE 4 &amp;hellip;. 恩，还美其名曰 : stable。
而 experimental 仓库里的 KDE 4.6, 恩， experimental, 其实才是最稳定的。
对于多数软件来说，大版本号最第二大，小版本号最大的软件才是最稳定的。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;比如说， Linux, 2.6.39 显然没有 2.6.39.2 来的稳定。虽然后者是后来出现的。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;dabian 的哲学来说，就是不稳定的。 定期发布 Release , 意味着必须使用稳定版本，否则就等于发布 unstable ， 这是不行的。
但是稳定版本，通常是比较新的版本，这样定期发布 Release , 意味着必须使用过时的版本。&lt;/p&gt;</description>
    </item>
    <item>
      <title>为什么你应该让你的项目使用 autotools 而不是别的编译系统</title>
      <link>https://microcai.org/2011/05/26/whyautotools.html</link>
      <pubDate>Thu, 26 May 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/05/26/whyautotools.html</guid>
      <description>&lt;p&gt;编写软件离不开编译。&lt;/p&gt;
&lt;p&gt;简单的编译，无外乎直接调用 gcc 去编译。&lt;/p&gt;
&lt;p&gt;简单又不简单，当源文件不止一个的时候，麻烦的事情就随之而来。&lt;/p&gt;
&lt;p&gt;当然，这个时候你可以选择 Makefile&lt;/p&gt;
&lt;p&gt;但是，如果要求你的 Makefile 支持很多标准化操作，比如&lt;/p&gt;
&lt;p&gt;make install DESTDIR=&amp;hellip;.&lt;/p&gt;
&lt;p&gt;make dist-bzip2&lt;/p&gt;
&lt;p&gt;你怎么打算呢？&lt;/p&gt;
&lt;p&gt;自然，你需要一个自动创建 Makefile 的工具。&lt;/p&gt;
&lt;p&gt;你有很多选择:&lt;/p&gt;
&lt;p&gt;imake&lt;/p&gt;
&lt;p&gt;qmake&lt;/p&gt;
&lt;p&gt;scons&lt;/p&gt;
&lt;p&gt;cmake&lt;/p&gt;
&lt;p&gt;然而，他们都虽然简单，却不是最终用户友好的。&lt;/p&gt;
&lt;p&gt;因为，最终的用户最习惯的软件编译方式就是三部曲&lt;/p&gt;
&lt;p&gt;./configure &amp;ndash;options&lt;/p&gt;
&lt;p&gt;make&lt;/p&gt;
&lt;p&gt;sudo make install&lt;/p&gt;
&lt;p&gt;而开发人员也可以直接 make dist-bzip2 生成发布用的 tarball.&lt;/p&gt;
&lt;p&gt;当然，如果有嵌入式的用户，他们自然会喜欢&lt;/p&gt;
&lt;p&gt;./configure &amp;ndash;host=arch-machine-os&lt;/p&gt;
&lt;p&gt;进行交叉编译。&lt;/p&gt;
&lt;p&gt;这是他们最最最熟悉的方式。&lt;/p&gt;
&lt;p&gt;如果你想让你的用户能马上上手知道如何编译你的软件，那么，请使用 autotools&lt;/p&gt;
&lt;p&gt;这是 autotools 带给你的最大的好处。别忘记，你的开发者，一开始也是用户，如果他们第一次就编译失败，他们很有可能因此走掉。&lt;/p&gt;
&lt;p&gt;autotools 就是一把瑞士军刀，一开始就使用autotools，能让你的项目不会到最后被编译系统拖后腿。&lt;/p&gt;
&lt;p&gt;记住， ebuild 文件的复杂度代表了一个软件的编译系统的友好程度。&lt;/p&gt;
&lt;p&gt;而简单的 ebuild 文件只可能出现于使用 autotools 的软件中。&lt;/p&gt;
&lt;p&gt;Autotools can be quite tricky for newcomers, but when you start using them on a daily basis you find it&amp;rsquo;s a lot easier than having to deal with manual makefiles or other strange build tools such as imake or qmake, or even worse, special autotools-like build scripts that try to recognize the system they are building on. Autotools makes it simple to support new OSes and new hardware platforms, and saves maintainers and porters from having to learn how to custom-build a system to fix compilation. By carefully writing a script, developers can support new platforms without any changes at all.&lt;/p&gt;</description>
    </item>
    <item>
      <title>BIOS 是如何访问在内存还没有的时候检测并初始化内存的</title>
      <link>https://microcai.org/2011/05/08/howbiosdetectmemory.html</link>
      <pubDate>Sun, 08 May 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/05/08/howbiosdetectmemory.html</guid>
      <description>&lt;p&gt;首先必须明确的一点是， BIOS 运行初期，CPU 其实是不能访问内存的。&lt;/p&gt;
&lt;p&gt;BIOS 所在的 FLASH 是那种可以被 CPU 直接寻址的 FLASH 芯片。被都固定在
0x4FFFF (记不清具体地址了) 地址上了。类似 ARM 使用的 NOR FLASH。 uboot
就在 NOR FLASH上。&lt;/p&gt;
&lt;p&gt;然后，BIOS 初始化代码开始通过寄存器和北桥芯片沟通。
因为 BIOS 就是版卡厂商制作的，这不成问题。使用固化的 IO 地址就可以了。&lt;/p&gt;
&lt;p&gt;成功和北桥联系上后， BIOS 继续前进，利用北桥提供的寄存器操控SMBUS, SMBUS
是一种 I2C 总线，每个 SMBUS 设备都有一个固定的地址。SDRAM 的 EEPROM 就可
以通过 SMBUS 访问！ 而 SDRAM 通常在 0x50 ~ 0x53 这4个地址上，对于主板上
的4个内存插槽。不过，主板厂商也可以改变这些地址。反正 BIOS 是自己出的，
可以固化这些地址，无所谓。&lt;/p&gt;
&lt;p&gt;读取 SDRAM eeprom 里超过 17 个参数后。 BIOS 就可以使用这些参数设置好北桥
的寄存器了。而在这之前， BIOS 严重依赖 CPU 的寄存器做这些操作，不能使用
任何内存！ 北桥用来控制内存的寄存器地址，又是一个每个版卡都不一样的地方
了。无所谓， BIOS 自己出，爱怎么用就怎么用。&lt;/p&gt;</description>
    </item>
    <item>
      <title>chroot to arm on an x86 Gentoo</title>
      <link>https://microcai.org/2011/04/26/chrootarm.html</link>
      <pubDate>Tue, 26 Apr 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/04/26/chrootarm.html</guid>
      <description>&lt;p&gt;在早上的邮件中，我指出 Gentoo 是如何方便的构筑交叉环境的。
现在，我要指出，我还要运行里面的arm程序！ 在 chroot 环境中，真正的把它当
作一个发行版！&lt;/p&gt;
&lt;p&gt;我使用的是 crossdev -t arm-unknow-linux-gnueabi 编译的 arm 交叉工具链。
这时候 arm 其实被安装到了  /usr/arm-unknow-linux-gnueabi/&lt;/p&gt;
&lt;p&gt;/usr/arm-unknow-linux-gnueabi/ 下面有完整目录结构，相当于一个 arm 发行版。&lt;/p&gt;
&lt;p&gt;而且之后也会多了一个工具叫 arm-unknow-linux-gnueabi-emerge&lt;/p&gt;
&lt;p&gt;我们的第一个主角就出来了。我们需要 busybox&lt;/p&gt;
&lt;p&gt;USE=&amp;quot;-ipv6 static -pam make-symlinks&amp;quot; &lt;br&gt;
arm-unknow-linux-gnueabi-emerge busybox -av&lt;/p&gt;
&lt;p&gt;之后我们的 /usr/arm-unknow-linux-gnueabi/ 其实已经可以作为一个基本完整的
arm 系统的根目录了。&lt;/p&gt;
&lt;p&gt;我们需要第二个主角，一个解释器。qemu-user !&lt;/p&gt;
&lt;p&gt;export QEMU_USER_TARGETS=&amp;ldquo;arm&amp;rdquo;
export USE=&amp;quot;-* static&amp;quot;
emerge qemu -av &amp;ndash;root=/usr/arm-unknow-linux-gnueabi/ -O&lt;/p&gt;
&lt;p&gt;这样 /usr/arm-unknow-linux-gnueabi/usr/bin/qemu-arm 就成为这个 arm 系统
的解释器了，注意，静态链接是必须的 wink.gif&lt;/p&gt;
&lt;p&gt;接着，我们需要内核的支持
echo
&amp;lsquo;:arm:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/arm-unknow-linux-gnueabi/usr/bin/qemu-arm:&amp;rsquo;&lt;/p&gt;
&lt;blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;/proc/sys/fs/binfmt_misc/register&lt;/p&gt;
&lt;/blockquote&gt;
&lt;/blockquote&gt;
&lt;p&gt;当然，要需要第三个主角，一个 bash wink.gif
arm-unknow-linux-gnueabi-emerge bash -av&lt;/p&gt;
&lt;p&gt;好了，准备工作就完成了。&lt;/p&gt;
&lt;p&gt;chroot /usr/arm-unknow-linux-gnueabi/ /bin/bash&lt;/p&gt;</description>
    </item>
    <item>
      <title>2.6.38.4 内核对 tq2440 支持补丁</title>
      <link>https://microcai.org/2011/04/22/patchfortq2440.html</link>
      <pubDate>Fri, 22 Apr 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/04/22/patchfortq2440.html</guid>
      <description>&lt;p&gt;最近折腾了很久，总算搞定了。&lt;/p&gt;
&lt;p&gt;发个补丁，希望大家不要再折腾了，而且也不要看网上的所谓垃圾移植指南了，都是 bullshit.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  From 144759a9929f0858398b834a5cbfdb79ce56f077 Mon Sep 17 00:00:00 2001 
  From: microcai &amp;lt;microcai@fedoraproject.org&amp;gt; 
  Date: Sat, 30 Apr 2011 14:28:11 +0800 
  Subject: [PATCH 2/4] =TQ 2440 补丁 
  MIME-Version: 1.0 
  Content-Type: text/plain; charset=UTF-8 
  Content-Transfer-Encoding: 8bit 

  --- 
  arch/arm/mach-s3c2440/Kconfig | 46 +++ 
  arch/arm/mach-s3c2440/Makefile | 1 + 
  arch/arm/mach-s3c2440/mach-tq2440.c | 539 +++++++++++++++++++++++++++++++++++ 
  3 files changed, 586 insertions(+), 0 deletions(-) 
  create mode 100644 arch/arm/mach-s3c2440/mach-tq2440.c 

  diff --git a/arch/arm/mach-s3c2440/Kconfig b/arch/arm/mach-s3c2440/Kconfig 
  index 50825a3..9afdfe5 100644 
  --- a/arch/arm/mach-s3c2440/Kconfig 
  +++ b/arch/arm/mach-s3c2440/Kconfig 
  @@ -203,4 +203,50 @@ config MACH_RX1950 
  help 
  Say Y here if you&#39;re using HP iPAQ rx1950 

  +config MACH_TQ2440 
  + bool &amp;quot;TQ 2440&amp;quot; 
  + select MACH_SMDK 
  + select CPU_S3C2440 
  + select S3C_DEV_NAND 
  + select MTD 
  + select MTD_NAND 
  + select MTD_NAND_S3C2410 
  + select S3C_DEV_USB_HOST 
  + select RTC_DRV_S3C if RTC_CLASS 
  + select S3C2410_WATCHDOG if WATCHDOG 
  + select SND_SOC_SAMSUNG_S3C24XX_UDA134X if SOUND 
  + select USB_GADGET_S3C2410 
  + select FB_S3C2410 if FB 
  + select SERIAL_SAMSUNG 
  + select SERIAL_S3C2440 
  + select SERIAL_SAMSUNG_CONSOLE 
  + select SERIO 
  + select AEABI 
  + select BINFMT_ELF 
  + select CPU_FREQ_S3C24XX if CPU_FREQ 
  + select DM9000 if NETDEVICES 
  + select DEPRECATED_PARAM_STRUCT 
  + 
  + help 
  + Say Y here if you are using the TQ 2440 Machine 
  + development system 
  + 
  +choice 
  + prompt &amp;quot;LCD size&amp;quot; 
  + default FB_S3C24X0_LCD480272 
  + depends on FB_S3C2410 &amp;amp;&amp;amp; MACH_TQ2440 
  + 
  +config FB_S3C24X0_LCD480272 
  + bool &amp;quot;4.3in LCD&amp;quot; 
  + help 
  + Support 4.3in LCD 
  + 
  + 
  +config FB_S3C24X0_TFT640480 
  + bool &amp;quot;640x480 LCD&amp;quot; 
  + 
  + 
  +endchoice 
  + 
  + 
  endmenu 
  diff --git a/arch/arm/mach-s3c2440/Makefile b/arch/arm/mach-s3c2440/Makefile 
  index d5440fa..c001bdd 100644 
  --- a/arch/arm/mach-s3c2440/Makefile 
  +++ b/arch/arm/mach-s3c2440/Makefile 
  @@ -26,6 +26,7 @@ obj-$(CONFIG_S3C2440_PLL_16934400) += s3c2440-pll-16934400.o 

  # Machine support 

  +obj-$(CONFIG_MACH_TQ2440) += mach-tq2440.o 
  obj-$(CONFIG_MACH_ANUBIS) += mach-anubis.o 
  obj-$(CONFIG_MACH_OSIRIS) += mach-osiris.o 
  obj-$(CONFIG_MACH_RX3715) += mach-rx3715.o 
  diff --git a/arch/arm/mach-s3c2440/mach-tq2440.c b/arch/arm/mach-s3c2440/mach-tq2440.c 
  new file mode 100644 
  index 0000000..3d1bef7 
  --- /dev/null 
  +++ b/arch/arm/mach-s3c2440/mach-tq2440.c 
  @@ -0,0 +1,539 @@ 
  +/* linux/arch/arm/mach-s3c2440/mach-smdk2440.c 
  + * 
  + * Copyright (c) 2004-2005 Simtec Electronics 
  + * Ben Dooks &amp;lt;ben@simtec.co.uk&amp;gt; 
  + * 
  + * http://www.fluff.org/ben/smdk2440/ 
  + * 
  + * Thanks to Dimity Andric and TomTom for the loan of an SMDK2440. 
  + * 
  + * This program is free software; you can redistribute it and/or modify 
  + * it under the terms of the GNU General Public License version 2 as 
  + * published by the Free Software Foundation. 
  + * 
  +*/ 
  + 
  +#include &amp;lt;linux/kernel.h&amp;gt; 
  +#include &amp;lt;linux/types.h&amp;gt; 
  +#include &amp;lt;linux/interrupt.h&amp;gt; 
  +#include &amp;lt;linux/list.h&amp;gt; 
  +#include &amp;lt;linux/timer.h&amp;gt; 
  +#include &amp;lt;linux/init.h&amp;gt; 
  +#include &amp;lt;linux/serial_core.h&amp;gt; 
  +#include &amp;lt;linux/platform_device.h&amp;gt; 
  +#include &amp;lt;linux/mtd/mtd.h&amp;gt; 
  +#include &amp;lt;linux/mtd/nand.h&amp;gt; 
  +#include &amp;lt;linux/mtd/nand_ecc.h&amp;gt; 
  +#include &amp;lt;linux/mtd/partitions.h&amp;gt; 
  +#include &amp;lt;linux/i2c/at24.h&amp;gt; 
  +#include &amp;lt;linux/i2c.h&amp;gt; 
  +#include &amp;lt;linux/io.h&amp;gt; 
  +#include &amp;lt;linux/input.h&amp;gt; 
  +#include &amp;lt;linux/dm9000.h&amp;gt; 
  +#include &amp;lt;linux/gpio_keys.h&amp;gt; 
  +#include &amp;lt;linux/mmc/host.h&amp;gt; 
  +#include &amp;lt;sound/s3c24xx_uda134x.h&amp;gt; 
  + 
  +#include &amp;lt;asm/mach/arch.h&amp;gt; 
  +#include &amp;lt;asm/mach/map.h&amp;gt; 
  +#include &amp;lt;asm/mach/irq.h&amp;gt; 
  + 
  +#include &amp;lt;mach/hardware.h&amp;gt; 
  +#include &amp;lt;asm/irq.h&amp;gt; 
  +#include &amp;lt;asm/mach-types.h&amp;gt; 
  + 
  +#include &amp;lt;plat/regs-serial.h&amp;gt; 
  +#include &amp;lt;plat/regs-adc.h&amp;gt; 
  +#include &amp;lt;mach/regs-mem.h&amp;gt; 
  +#include &amp;lt;plat/iic.h&amp;gt; 
  +#include &amp;lt;plat/nand.h&amp;gt; 
  +#include &amp;lt;plat/s3c2410.h&amp;gt; 
  +#include &amp;lt;plat/s3c244x.h&amp;gt; 
  +#include &amp;lt;plat/clock.h&amp;gt; 
  +#include &amp;lt;plat/devs.h&amp;gt; 
  +#include &amp;lt;plat/cpu.h&amp;gt; 
  +#include &amp;lt;plat/udc.h&amp;gt; 
  +#include &amp;lt;plat/pm.h&amp;gt; 
  +#include &amp;lt;plat/ts.h&amp;gt; 
  +#include &amp;lt;plat/mci.h&amp;gt; 
  + 
  +#include &amp;lt;mach/fb.h&amp;gt; 
  +#include &amp;lt;mach/gpio-fns.h&amp;gt; 
  +#include &amp;lt;mach/regs-gpio.h&amp;gt; 
  +#include &amp;lt;mach/regs-lcd.h&amp;gt; 
  +#include &amp;lt;mach/leds-gpio.h&amp;gt; 
  +#include &amp;lt;mach/idle.h&amp;gt; 
  + 
  + 
  +/*NAND*/ 
  + 
  +static struct mtd_partition smdk_default_nand_part[] = { 
  + 
  + [0] = { 
  + 
  + .name = &amp;quot;uboot&amp;quot;, 
  + 
  + .offset = 0x00000000, 
  + .size = SZ_2M, 
  + 
  + }, 
  + [1] = { 
  + 
  + .name = &amp;quot;kernel&amp;quot;, 
  + .offset = SZ_2M, 
  + .size = SZ_2M + SZ_1M, 
  + }, 
  + 
  + [2] = { 
  + .name = &amp;quot;yaffs2&amp;quot;, 
  + .offset = SZ_4M+SZ_1M, 
  + .size = MTDPART_SIZ_FULL, 
  + } 
  +}; 
  + 
  +static struct s3c2410_nand_set smdk_nand_sets[] = { 
  + [0] = { 
  + .disable_ecc = 1, // 在这里设置才是正确的 
  + .name = &amp;quot;NAND&amp;quot;, 
  + .nr_chips = 1, 
  + .nr_partitions = ARRAY_SIZE(smdk_default_nand_part), 
  + .partitions = smdk_default_nand_part, 
  + }, 
  +}; 
  + 
  + 
  +static struct s3c2410_platform_nand smdk_nand_info = { 
  + .tacls = 20, 
  + .twrph0 = 60, 
  + .twrph1 = 20, 
  + .nr_sets = ARRAY_SIZE(smdk_nand_sets), 
  + .sets = smdk_nand_sets, 
  +}; 
  + 
  + 
  +/*IO*/ 
  +static struct map_desc tq2440_iodesc[] = { 
  + /* ISA IO Space map (memory space selected by A24) */ 
  + 
  + { 
  + .virtual = (u32)S3C24XX_VA_ISA_WORD, 
  + .pfn = __phys_to_pfn(S3C2410_CS2), 
  + .length = 0x10000, 
  + .type = MT_DEVICE, 
  + }, { 
  + .virtual = (u32)S3C24XX_VA_ISA_WORD + 0x10000, 
  + .pfn = __phys_to_pfn(S3C2410_CS2 + (1&amp;lt;&amp;lt;24)), 
  + .length = SZ_4M, 
  + .type = MT_DEVICE, 
  + }, { 
  + .virtual = (u32)S3C24XX_VA_ISA_BYTE, 
  + .pfn = __phys_to_pfn(S3C2410_CS2), 
  + .length = 0x10000, 
  + .type = MT_DEVICE, 
  + }, { 
  + .virtual = (u32)S3C24XX_VA_ISA_BYTE + 0x10000, 
  + .pfn = __phys_to_pfn(S3C2410_CS2 + (1&amp;lt;&amp;lt;24)), 
  + .length = SZ_4M, 
  + .type = MT_DEVICE, 
  + } 
  +}; 
  + 
  +#define UCON S3C2410_UCON_DEFAULT | S3C2410_UCON_UCLK 
  +#define ULCON S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB 
  +#define UFCON S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE 
  + 
  +static struct s3c2410_uartcfg tq2440_uartcfgs[] = { 
  + [0] = { 
  + .hwport = 0, 
  + .flags = 0, 
  + .ucon = 0x3c5, 
  + .ulcon = 0x03, 
  + .ufcon = 0x51, 
  + }, 
  +}; 
  + 
  +/* LCD driver info */ 
  + 
  +static struct s3c2410fb_display tq2440_lcd_cfg = { 
  + 
  + .lcdcon5 = S3C2410_LCDCON5_FRM565 | 
  + S3C2410_LCDCON5_INVVLINE | 
  + S3C2410_LCDCON5_INVVFRAME | 
  + S3C2410_LCDCON5_PWREN | 
  + S3C2410_LCDCON5_HWSWP, 
  + 
  + .type = S3C2410_LCDCON1_TFT, 
  + 
  +#if defined(CONFIG_FB_S3C24X0_LCD480272) 
  + .width = 480, 
  + .height = 272, 
  + 
  + .pixclock = 40000, /* HCLK 100 MHz, divisor 1 */ 
  + .xres = 480, 
  + .yres = 272, 
  + .bpp = 16, 
  + .left_margin = 15, /* for HFPD*/ 
  + .right_margin = 16, /* for HBPD*/ 
  + .hsync_len = 30, /* for HSPW*/ 
  + .upper_margin = 4, /* for VFPD*/ 
  + .lower_margin = 2, /* for VBPD*/ 
  + .vsync_len = 8, /* for VSPW*/ 
  + 
  +#elif defined(CONFIG_FB_S3C24X0_TFT640480) 
  + .width = 640, 
  + .height = 480, 
  + 
  + .pixclock = 40000, /* HCLK 100 MHz, divisor 1 */ 
  + .xres = 640, 
  + .yres = 480, 
  + .bpp = 16, 
  + .left_margin = 40, /* for HFPD*/ 
  + .right_margin = 67, /* for HBPD*/ 
  + .hsync_len = 31, /* for HSPW*/ 
  + .upper_margin = 5, /* for VFPD*/ 
  + .lower_margin = 25, /* for VBPD*/ 
  + .vsync_len = 1, /* for VSPW*/ 
  + 
  +#else 
  + .width = 240, 
  + .height = 320, 
  + 
  + .pixclock = 166667, /* HCLK 60 MHz, divisor 10 */ 
  + .xres = 240, 
  + .yres = 320, 
  + .bpp = 16, 
  + .left_margin = 20, 
  + .right_margin = 8, 
  + .hsync_len = 4, 
  + .upper_margin = 8, 
  + .lower_margin = 7, 
  + .vsync_len = 4, 
  +#endif 
  + 
  +}; 
  + 
  +static struct s3c2410fb_mach_info tq2440_fb_info = { 
  + .displays = &amp;amp;tq2440_lcd_cfg, 
  + .num_displays = 1, 
  + .default_display = 0, 
  +}; 
  + 
  + 
  +static struct resource s3c_dm9000_resource[] = { 
  + [0] = { 
  + .start = S3C2410_CS4, 
  + .end = S3C2410_CS4+3, 
  + .flags = IORESOURCE_MEM, 
  + }, 
  + 
  + [1] = { 
  + .start = S3C2410_CS4+4, 
  + .end = S3C2410_CS4+4+3, 
  + .flags = IORESOURCE_MEM, 
  + }, 
  + 
  + [2] = { 
  + .start = IRQ_EINT7, 
  + .end =IRQ_EINT7, 
  + .flags =IORESOURCE_IRQ|IORESOURCE_IRQ_HIGHEDGE|IORESOURCE_IRQ_SHAREABLE, 
  + } 
  +}; 
  + 
  +static struct dm9000_plat_data dm9k_plat_data = { 
  + .flags = DM9000_PLATF_16BITONLY|DM9000_PLATF_NO_EEPROM, 
  + .dev_addr = &amp;quot;&amp;quot;, 
  + }; 
  + 
  +static struct platform_device s3c_device_dm9k = { 
  + .name = &amp;quot;dm9000&amp;quot;, 
  + .id = 0, 
  + .num_resources = ARRAY_SIZE(s3c_dm9000_resource), 
  + .resource = s3c_dm9000_resource, 
  + .dev = { 
  + .platform_data = &amp;amp;dm9k_plat_data, 
  + } 
  +}; 
  + 
  + 
  +/*设置udc回调函数udc_pullup()用于使能/禁止UDC上拉电阻*/ 
  +/*udc*/ 
  +static void udc_pullup(enum s3c2410_udc_cmd_e cmd) 
  +{ 
  + switch(cmd) 
  + { 
  + case S3C2410_UDC_P_ENABLE: 
  + s3c2410_gpio_setpin(S3C2410_GPG(12),1); 
  + break; 
  + case S3C2410_UDC_P_DISABLE: 
  + s3c2410_gpio_setpin(S3C2410_GPG(12),0); 
  + break; 
  + case S3C2410_UDC_P_RESET: 
  + break; 
  + default: 
  + break; 
  + } 
  +} 
  +static struct s3c2410_udc_mach_info udc_machine = { 
  + .udc_command = udc_pullup, 
  +}; 
  + 
  + 
  +/*KEY*/ 
  +static struct gpio_keys_button mini2440_buttons[] = { 
  + { 
  + .gpio = S3C2410_GPF(1), /* K1 */ 
  + .code = KEY_UP, 
  + .desc = &amp;quot;UP&amp;quot;, 
  + .active_low = 1, 
  + }, 
  + { 
  + .gpio = S3C2410_GPF(4), /* K2 */ 
  + .code = KEY_DOWN, 
  + .desc = &amp;quot;DOWN&amp;quot;, 
  + .active_low = 1, 
  + }, 
  + { 
  + .gpio = S3C2410_GPF(2), /* K3 */ 
  + .code = KEY_LEFT, 
  + .desc = &amp;quot;LEFT&amp;quot;, 
  + .active_low = 1, 
  + }, 
  + { 
  + .gpio = S3C2410_GPF(0), /* K4 */ 
  + .code = KEY_RIGHT, 
  + .desc = &amp;quot;RIGHT&amp;quot;, 
  + .active_low = 1, 
  + }, 
  + 
  +}; 
  + 
  +static struct gpio_keys_platform_data mini2440_button_data = { 
  + .buttons = mini2440_buttons, 
  + .nbuttons = ARRAY_SIZE(mini2440_buttons), 
  +}; 
  + 
  +static struct platform_device mini2440_button_device = { 
  + .name = &amp;quot;gpio-keys&amp;quot;, 
  + .id = -1, 
  + .dev = { 
  + .platform_data = &amp;amp;mini2440_button_data, 
  + } 
  +}; 
  + 
  +/* LED devices */ 
  + 
  +static struct s3c24xx_led_platdata smdk_pdata_led4 = { 
  + .gpio = S3C2410_GPB(5), 
  + .flags = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
  + .name = &amp;quot;led4&amp;quot;, 
  + .def_trigger = &amp;quot;timer&amp;quot;, 
  +}; 
  + 
  +static struct s3c24xx_led_platdata smdk_pdata_led5 = { 
  + .gpio = S3C2410_GPB(6), 
  + .flags = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
  + .name = &amp;quot;led5&amp;quot;, 
  + .def_trigger = &amp;quot;nand-disk&amp;quot;, 
  +}; 
  + 
  +static struct s3c24xx_led_platdata smdk_pdata_led6 = { 
  + .gpio = S3C2410_GPB(7), 
  + .flags = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
  + .name = &amp;quot;led6&amp;quot;, 
  +}; 
  + 
  +static struct s3c24xx_led_platdata smdk_pdata_led7 = { 
  + .gpio = S3C2410_GPB(8), 
  + .flags = S3C24XX_LEDF_ACTLOW | S3C24XX_LEDF_TRISTATE, 
  + .name = &amp;quot;led7&amp;quot;, 
  +}; 
  + 
  +static struct platform_device smdk_led4 = { 
  + .name = &amp;quot;s3c24xx_led&amp;quot;, 
  + .id = 0, 
  + .dev = { 
  + .platform_data = &amp;amp;smdk_pdata_led4, 
  + }, 
  +}; 
  + 
  +static struct platform_device smdk_led5 = { 
  + .name = &amp;quot;s3c24xx_led&amp;quot;, 
  + .id = 1, 
  + .dev = { 
  + .platform_data = &amp;amp;smdk_pdata_led5, 
  + }, 
  +}; 
  + 
  +static struct platform_device smdk_led6 = { 
  + .name = &amp;quot;s3c24xx_led&amp;quot;, 
  + .id = 2, 
  + .dev = { 
  + .platform_data = &amp;amp;smdk_pdata_led6, 
  + }, 
  +}; 
  + 
  +static struct platform_device smdk_led7 = { 
  + .name = &amp;quot;s3c24xx_led&amp;quot;, 
  + .id = 3, 
  + .dev = { 
  + .platform_data = &amp;amp;smdk_pdata_led7, 
  + }, 
  +}; 
  + 
  +static struct s3c24xx_uda134x_platform_data tq2440_audio_pins = { 
  + .l3_clk = S3C2410_GPB(4), 
  + .l3_data = S3C2410_GPB(3), 
  + .l3_mode = S3C2410_GPB(2), 
  + .model = UDA134X_UDA1341, 
  +}; 
  + 
  +static struct platform_device tq2440_audio = { 
  + .name = &amp;quot;s3c24xx_uda134x&amp;quot;, 
  + .id = 0, 
  + .dev = { 
  + .platform_data = &amp;amp;tq2440_audio_pins, 
  + }, 
  +}; 
  + 
  +static struct platform_device uda1340_codec = { 
  + .name = &amp;quot;uda134x-codec&amp;quot;, 
  +}; 
  + 
  +/* Touchscreen */ 
  +static struct s3c2410_ts_mach_info tq2400_ts_info = { 
  + .delay = 10000, 
  + .presc = 49, 
  + .oversampling_shift = 2, 
  +}; 
  + 
  +static struct resource s3c_adc_resource[] = { 
  + [0] = { 
  + .start = S3C2410_PA_ADC, 
  + .end = S3C2410_PA_ADC + 0x20 , 
  + .flags = IORESOURCE_MEM, 
  + }, 
  + [1] = { 
  + .start = IRQ_TC, 
  + .end = IRQ_TC, 
  + .flags = IORESOURCE_IRQ, 
  + }, 
  + [2] = { 
  + .start = IRQ_ADC, 
  + .end = IRQ_ADC, 
  + .flags = IORESOURCE_IRQ, 
  + }, 
  +}; 
  + 
  + 
  +/* 
  + * I2C devices 
  + */ 
  +static struct at24_platform_data at24c08 = { 
  + .byte_len = SZ_8K / 8, 
  + .page_size = 16, 
  +}; 
  + 
  +static struct i2c_board_info mini2440_i2c_devs[] = { 
  + { 
  + I2C_BOARD_INFO(&amp;quot;24c08&amp;quot;, 0x50), 
  + .platform_data = &amp;amp;at24c08, 
  + }, 
  +}; 
  + 
  + 
  +static struct platform_device *tq2440_devices[] = { 
  + &amp;amp;s3c_device_adc, 
  + &amp;amp;s3c_device_ts, 
  + &amp;amp;s3c_device_ohci, // s3c24xx_ohci 
  + &amp;amp;s3c_device_wdt, // 看门狗狗 
  + &amp;amp;s3c_device_lcd, 
  + &amp;amp;s3c_device_i2c0, 
  + &amp;amp;s3c_device_iis, 
  + &amp;amp;s3c_device_nand, // MTD NAND 分区表 
  + &amp;amp;s3c_device_dm9k, // 特别的DM9000网卡芯片 
  + &amp;amp;s3c_device_rtc, 
  + &amp;amp;mini2440_button_device, 
  + &amp;amp;s3c_device_sdi, // SD 卡读卡器 
  + &amp;amp;s3c_device_usbgadget, 
  + &amp;amp;uda1340_codec, 
  + &amp;amp;tq2440_audio, // ALSA 声卡 
  + &amp;amp;samsung_asoc_dma, 
  + &amp;amp;smdk_led4, 
  + &amp;amp;smdk_led5, 
  + &amp;amp;smdk_led6, 
  + &amp;amp;smdk_led7, 
  +}; 
  + 
  +/* MMC/SD */ 
  + 
  +static struct s3c24xx_mci_pdata mini2440_mmc_cfg = { 
  + .gpio_detect = S3C2410_GPG(8), 
  + .gpio_wprotect = S3C2410_GPH(8), 
  + .set_power = NULL, 
  + .ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34, 
  +}; 
  + 
  +static void __init tq2440_map_io(void) 
  +{ 
  + s3c24xx_init_io(tq2440_iodesc, ARRAY_SIZE(tq2440_iodesc)); 
  + s3c24xx_init_clocks(12000000); 
  + s3c24xx_init_uarts(tq2440_uartcfgs, ARRAY_SIZE(tq2440_uartcfgs)); 
  +} 
  + 
  +static void __init tq2440_machine_init(void) 
  +{ 
  + int i; 
  + 
  + s3c24xx_fb_set_platdata(&amp;amp;tq2440_fb_info); 
  + s3c_i2c0_set_platdata(NULL); 
  + 
  + s3c2410_gpio_cfgpin(S3C2410_GPG(8),S3C2410_GPG8_EINT16); 
  + 
  + s3c_nand_set_platdata(&amp;amp;smdk_nand_info); 
  + s3c24xx_mci_set_platdata(&amp;amp;mini2440_mmc_cfg); 
  + 
  +// s3c_device_adc.num_resources = ARRAY_SIZE(s3c_adc_resource); 
  +// s3c_device_adc.resource = s3c_adc_resource; 
  + 
  + s3c_device_ts.dev.platform_data = &amp;amp;tq2400_ts_info; 
  + 
  + 
  +#ifdef CONFIG_DM9000 
  + *((volatile unsigned int *)S3C2410_BANKCON4) = 0x1f7c; //config time seq 
  +#endif 
  + 
  + /* mark the key as input, without pullups (there is one on the board) */ 
  + for ( i = 0; i &amp;lt; ARRAY_SIZE(mini2440_buttons); i++) { 
  + s3c_gpio_setpull(mini2440_buttons[i].gpio, S3C_GPIO_PULL_UP); 
  + s3c_gpio_cfgpin(mini2440_buttons[i].gpio, S3C2410_GPIO_INPUT); 
  + } 
  + 
  + s3c24xx_mci_set_platdata(&amp;amp;mini2440_mmc_cfg); 
  + 
  + i2c_register_board_info(0, mini2440_i2c_devs, 
  + ARRAY_SIZE(mini2440_i2c_devs)); 
  + 
  + platform_add_devices(tq2440_devices, ARRAY_SIZE(tq2440_devices)); 
  + 
  + s3c2410_gpio_setpin(S3C2410_GPG(12),0); 
  + s3c2410_gpio_cfgpin(S3C2410_GPG(12),S3C2410_GPIO_OUTPUT); 
  + s3c24xx_udc_set_platdata(&amp;amp;udc_machine); 
  +} 
  + 
  +#define MACH_TYPE_168 168 
  +/*For some reason , my machine is ID 168*/ 
  +MACHINE_START(168, &amp;quot;TQ2440-168&amp;quot;) 
  + .boot_params = S3C2410_SDRAM_PA + 0x100, 
  + .init_irq = s3c24xx_init_irq, 
  + .map_io = tq2440_map_io, 
  + .init_machine = tq2440_machine_init, 
  + .timer = &amp;amp;s3c24xx_timer, 
  +MACHINE_END 
  + 
  +MACHINE_START(TQ2440, &amp;quot;TQ2440&amp;quot;) 
  + .boot_params = S3C2410_SDRAM_PA + 0x100, 
  + .init_irq = s3c24xx_init_irq, 
  + .map_io = tq2440_map_io, 
  + .init_machine = tq2440_machine_init, 
  + .timer = &amp;amp;s3c24xx_timer, 
  +MACHINE_END 
  -- 
  1.7.5.rc3 

  From 119021354fa6001311db9f1df5d3ea8061a35f9b Mon Sep 17 00:00:00 2001 
  From: microcai &amp;lt;microcai@fedoraproject.org&amp;gt; 
  Date: Thu, 5 May 2011 14:40:44 +0800 
  Subject: [PATCH 3/4] add report for ABS_PRESSURE, this fix tslib problem that 
  not been able to detect pen-down and pen-up events. 

  --- 
  drivers/input/touchscreen/s3c2410_ts.c | 3 +++ 
  1 files changed, 3 insertions(+), 0 deletions(-) 

  diff --git a/drivers/input/touchscreen/s3c2410_ts.c b/drivers/input/touchscreen/s3c2410_ts.c 
  index 8feb7f3..ecab5d4 100644 
  --- a/drivers/input/touchscreen/s3c2410_ts.c 
  +++ b/drivers/input/touchscreen/s3c2410_ts.c 
  @@ -126,6 +126,7 @@ static void touch_timer_fire(unsigned long data) 
  input_report_abs(ts.input, ABS_Y, ts.yp); 

  input_report_key(ts.input, BTN_TOUCH, 1); 
  + input_report_abs(ts.input, ABS_PRESSURE, 1); 
  input_sync(ts.input); 

  ts.xp = 0; 
  @@ -140,6 +141,7 @@ static void touch_timer_fire(unsigned long data) 
  ts.count = 0; 

  input_report_key(ts.input, BTN_TOUCH, 0); 
  + input_report_abs(ts.input, ABS_PRESSURE, 0); 
  input_sync(ts.input); 

  writel(WAIT4INT | INT_DOWN, ts.io + S3C2410_ADCTSC); 
  @@ -318,6 +320,7 @@ static int __devinit s3c2410ts_probe(struct platform_device *pdev) 
  ts.input-&amp;gt;keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 
  input_set_abs_params(ts.input, ABS_X, 0, 0x3FF, 0, 0); 
  input_set_abs_params(ts.input, ABS_Y, 0, 0x3FF, 0, 0); 
  + input_set_abs_params(ts.input, ABS_PRESSURE, 0, 1, 0, 0); 

  ts.input-&amp;gt;name = &amp;quot;S3C24XX TouchScreen&amp;quot;; 
  ts.input-&amp;gt;id.bustype = BUS_HOST; 
  -- 
  1.7.5.rc3 

  From 4684013358b6edf0e8a790ef32de13a236cf7987 Mon Sep 17 00:00:00 2001 
  From: microcai &amp;lt;microcai@fedoraproject.org&amp;gt; 
  Date: Thu, 5 May 2011 16:19:53 +0800 
  Subject: [PATCH 4/4] fix some time later then driver not response 

  --- 
  drivers/input/touchscreen/s3c2410_ts.c | 1 + 
  1 files changed, 1 insertions(+), 0 deletions(-) 

  diff --git a/drivers/input/touchscreen/s3c2410_ts.c b/drivers/input/touchscreen/s3c2410_ts.c 
  index ecab5d4..db868d2 100644 
  --- a/drivers/input/touchscreen/s3c2410_ts.c 
  +++ b/drivers/input/touchscreen/s3c2410_ts.c 
  @@ -227,6 +227,7 @@ static void s3c24xx_ts_select(struct s3c_adc_client *client, unsigned select) 
  if (select) { 
  writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, 
  ts.io + S3C2410_ADCTSC); 
  + writel(readl(ts.io+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, ts.io+S3C2410_ADCCON); 
  } else { 
  mod_timer(&amp;amp;touch_timer, jiffies+1); 
  writel(WAIT4INT | INT_UP, ts.io + S3C2410_ADCTSC); 
  -- 
  1.7.5.rc3
&lt;/code&gt;&lt;/pre&gt;</description>
    </item>
    <item>
      <title>GPG 签名与加密</title>
      <link>https://microcai.org/2011/04/22/gpg.html</link>
      <pubDate>Fri, 22 Apr 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/04/22/gpg.html</guid>
      <description>&lt;p&gt;首先密码学的模型&lt;/p&gt;
&lt;p&gt;1） 通信双方的机器是没有问题的。没有木马，没有坏人。
2) 通信线路是不可靠的，有人监听，有人伪造信息&lt;/p&gt;
&lt;p&gt;那么，就要解决2个问题，首先，我得确信这个信息是你发送的，不是别人伪造你
发送的，俗称数字签名， 第二，我要确保没有人知道我们之间的通信，也就是加密。&lt;/p&gt;
&lt;p&gt;非对称加密的意思就是，同时有2个key. 用其中一个加密，只能用另一个解密。
这样，随机选一个做私钥，另一个公开做公钥就是下面我要讲的 GPG 签名与加密。&lt;/p&gt;
&lt;p&gt;对于 GPG 来说，GPG 会生成一个密钥对，一个是公钥，一个是私钥。&lt;/p&gt;
&lt;p&gt;对于公钥，你需要将它上传到公钥服务器。
对于私钥，要绝对反正泄露，并且不能丢失!!!! 我重复，不能丢失，也不能泄露。&lt;/p&gt;
&lt;p&gt;如果你要让别人相信你的邮件不是伪造的，那么你就需要进行签名。
签名就是用自己的私钥加密邮件。因为公钥是公开的，所以任何人都可以解密你的
邮件。但是只有用你的私钥才能发出那封邮件，所以别人可以肯定这是你的邮件，
不是别人伪造的。这就是用私钥进行签名的原因。&lt;/p&gt;
&lt;p&gt;如果是发送加密邮件，那么你必须有对方的 GPG 公钥。
然后你用 &lt;em&gt;对方&lt;/em&gt; 的 &lt;em&gt;公钥&lt;/em&gt; 加密邮件。&lt;/p&gt;
&lt;p&gt;因为这个时间上只有收件人有加密时使用的公钥的对应私钥，所以只有你的收件人
能解密这个邮件. 这样你就保证了你的邮件只有他能看到。PS， 你自己也不能解
密那个邮件。因为你没有他的私钥。&lt;/p&gt;
&lt;p&gt;加密和签名同时使用的时候，就可以保证&lt;/p&gt;
&lt;p&gt;1） 他可以确信邮件是你发送的
2） 你可以确信只有他能看那封邮件&lt;/p&gt;
&lt;p&gt;=====================================
但是，这个前提是，你怎么知道/确信指定的公钥就是他的？ 他怎么知道/确信某
个密钥就是你的！！！！&lt;/p&gt;
&lt;p&gt;这就引入了一个 信任机制。&lt;/p&gt;
&lt;p&gt;比如 A B C&lt;/p&gt;
&lt;p&gt;A 通过见面得知了 B 的公钥。这个时候 A 和 B 可以相互100%确认对方的公钥。&lt;/p&gt;
&lt;p&gt;这个时候来了个 C . C 自称他的公钥是 XXXX 。&lt;/p&gt;
&lt;p&gt;C 和 A 见过面。交换过公钥。&lt;/p&gt;
&lt;p&gt;然后 A 就给 C 的公钥签名，&lt;/p&gt;</description>
    </item>
    <item>
      <title>两种  Mem remap</title>
      <link>https://microcai.org/2011/04/22/4gmem.html</link>
      <pubDate>Fri, 22 Apr 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/04/22/4gmem.html</guid>
      <description>&lt;p&gt;安装4G内存操作系统却只报告 3.2G 是4G时代困扰我们的一个问题。&lt;/p&gt;
&lt;p&gt;解决办法需要3个条件齐备，缺一不可&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 内存控制器支持 &amp;gt; 4G 寻址
2. 操作系统支持 PAE 或者直接64位系统
3. BIOS 支持 mem remap
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;** &amp;gt; 4G 寻址的内存控制器，intel 平台的话要求至少是 945 以上的芯片组。
AMD 平台的话，内存控制器内置于 CPU, 只要是支持 64 位的 AMD CPU 就可以了。&lt;/p&gt;
&lt;p&gt;操作系统吧，不多解释。 32位的windows 使用 PAE 内核，或者64位 windows.
Linux 也一样。
这里要注意的是，开了 PAE 的 32位 windows 7 也不能识别 &amp;gt; 4G 的内存 &amp;hellip;&amp;hellip; ，可以使用 ReadyFor4G 这个小工具修改内核。&lt;/p&gt;
&lt;p&gt;这里是本文的重点。&lt;/p&gt;
&lt;p&gt;mem remap 就是重新布局 PCI 设备地址和 DRAM 地址。使原本要重叠的地址错开，分布到 &amp;gt; 4G 的地址空间上。
这样才能使安装的 4G DRAM 可以被全部寻址。&lt;/p&gt;</description>
    </item>
    <item>
      <title>为何我们不能回到过去</title>
      <link>https://microcai.org/2011/04/15/timetravel.html</link>
      <pubDate>Fri, 15 Apr 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/04/15/timetravel.html</guid>
      <description>&lt;p&gt;我们能回到过去么？&lt;/p&gt;
&lt;p&gt;答案是：不能。&lt;/p&gt;
&lt;p&gt;单个原子能回到过去么？&lt;/p&gt;
&lt;p&gt;答案是，可能。&lt;/p&gt;
&lt;p&gt;lol&lt;/p&gt;
&lt;p&gt;自从爱因斯坦否决了牛顿的时空观后，很多人就开始在理论上研究时空旅行。
时间是什么？ 时间由运动产生，没有运动，就没有时间。如果你周围的一切一切都变慢一倍，包括你自己的新陈代谢，那么，你还能知道时间变慢了么？ 决定不能。
时间就是相对的。想到这就很容易理解了。
于是，既然时间是相对的，能回到过去么？&lt;/p&gt;
&lt;p&gt;不能。时间在流逝，流逝的速率可以被运行、质量影响，但是，它在流逝，这是无法避免的。&lt;/p&gt;
&lt;p&gt;时间也符合熵增加原理。&lt;/p&gt;
&lt;p&gt;我重复，&lt;/p&gt;
&lt;p&gt;时间也符合熵增加原理。time is entropy&lt;/p&gt;
&lt;p&gt;时间也是熵的一种。&lt;/p&gt;</description>
    </item>
    <item>
      <title>gnome 的对与错</title>
      <link>https://microcai.org/2011/03/15/gnomefault.html</link>
      <pubDate>Tue, 15 Mar 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/03/15/gnomefault.html</guid>
      <description>&lt;p&gt;gnome-shell 也用了许久了。从一开始的新鲜到习惯， 再到离不开它。&lt;/p&gt;
&lt;p&gt;等新鲜感过去的时候，我发现我越来越不能忍受 gnome-shell 那容易崩溃的毛病了。&lt;/p&gt;
&lt;p&gt;在没升级 gnome 其他部件的时候， gnome-shell 崩溃总是会被自动重启。&lt;/p&gt;
&lt;p&gt;后来 ， gnome-shell 崩溃虽然也会被自动重启，可是 &amp;hellip; 如果连续崩溃两次间隔很短，则愚蠢的 gnome-session 就会断定 gnome-shell 出了问题，逼我注销 &amp;hellip;&lt;/p&gt;
&lt;p&gt;有这样子的么？ 我还有工作没保存 &amp;hellip; 还有聊天窗口在和人讨论呢！&lt;/p&gt;
&lt;p&gt;终于忍受不了了，我决定暂时离开 gnome&lt;/p&gt;
&lt;p&gt;决定用 KDE 了。&lt;/p&gt;
&lt;p&gt;KDE，很早以前用 红旗的时候用的。 诶，现在想起来 &amp;hellip; 用红旗的日子哦 ~~~&lt;/p&gt;</description>
    </item>
    <item>
      <title>Size is not everything</title>
      <link>https://microcai.org/2011/03/15/sizeofnoteverything.html</link>
      <pubDate>Tue, 15 Mar 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/03/15/sizeofnoteverything.html</guid>
      <description>&lt;p&gt;我们买笔记本的时候，往往笔记本只标示硬盘容量，却往往不标示他所使用的硬盘的牌子和速度。&lt;/p&gt;
&lt;p&gt;我们知道，硬盘的速度是一台电脑整体速度的瓶颈。它慢了，不管容量再大，电脑都快不起来。&lt;/p&gt;
&lt;p&gt;希捷  7200转 500G 带 16MB 缓存的硬盘，接口速度 300MB/s ， 突发数据传输率可达 160MB/s ，持续传输率平均能达到 80MB/s ,  一个要卖 超过 500&lt;/p&gt;
&lt;p&gt;同样容量的日立硬盘，5400转 8MB 缓存，接口速率都只是 150MB/s ，持续传输率不超过 60MB/s ， 一个卖不到 300&lt;/p&gt;
&lt;p&gt;看到这猫腻了吧？！&lt;/p&gt;
&lt;p&gt;别光看容量哦 !&lt;/p&gt;</description>
    </item>
    <item>
      <title>OSS4 deprecated ALSA and PulseAudio</title>
      <link>https://microcai.org/2011/02/15/oss4fuckofalsaandpa.html</link>
      <pubDate>Tue, 15 Feb 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/02/15/oss4fuckofalsaandpa.html</guid>
      <description>&lt;p&gt;Turst me , OSS4 = ALSA + PulseAudio , and all implemented in kernel. very low latency.&lt;/p&gt;
&lt;p&gt;OSS4 have kernel level mix feature which ALSA lack for years and that&amp;rsquo;s why PuleAudio fucked to burn.&lt;/p&gt;
&lt;p&gt;OSS4 also have per-process volume control which ALSA lack for years and that&amp;rsquo;s why PuleAudio fucked to burn.&lt;/p&gt;
&lt;p&gt;OSS4 is not a new API but a new implementation. So existing App won&amp;rsquo;t need any modification.
But when ALSA burn , every app need to re-write with the poor designed/doc-ed ALSA API.
When nearly lost app support ALSA, PA fuck the world again!!! And every app need to re-write with the PA api.&lt;/p&gt;</description>
    </item>
    <item>
      <title>force AHCI without BIOS</title>
      <link>https://microcai.org/2011/02/02/forceahci.html</link>
      <pubDate>Wed, 02 Feb 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/02/02/forceahci.html</guid>
      <description>&lt;p&gt;For long time, I&amp;rsquo;ve been using IDE mode for SATA.
长久以来，我一直在用SATA的IDE模式。&lt;/p&gt;
&lt;p&gt;but, SATA-II &amp;rsquo;s 300MB/s transfer rate and  NCQ features are missing .
但是 ，SATA-II 的 300MB/s 速度和 NCQ 功能都用不上了。&lt;/p&gt;
&lt;p&gt;So I decide to use AHCI.
于是我打定主意用 AHCI 了。&lt;/p&gt;
&lt;p&gt;But there is no AHCI option in my BIOS setup. What a fuck! I&amp;rsquo;m sure ICH8 is capable of AHCI.
但是 BIOS 设置里却米有 AHCI ! what a fuck ! 但是我确信ICH8芯片组有 AHCI 功能。&lt;/p&gt;</description>
    </item>
    <item>
      <title>in-kernel UNICODE font support for fbcon</title>
      <link>https://microcai.org/2011/01/01/cjktty.html</link>
      <pubDate>Sat, 01 Jan 2011 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2011/01/01/cjktty.html</guid>
      <description>&lt;p&gt;I first got this patch from 内核补丁：字符终端显示UTF-8字符串&lt;/p&gt;
&lt;p&gt;but , there is some problems &amp;hellip;.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;why not extending kernel VGA font to support UNICODE?&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;why so many duplicated code ? too many copy&amp;amp;past,  Linus
won&amp;rsquo;t take this patch&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Why all char  &amp;gt; 127 should be double-weight ?&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;I need to use setfont to set UNICODE font, with this patch,
I can&amp;rsquo;t. So , I made some changes &amp;hellip;
to eliminate all problems above.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;</description>
    </item>
    <item>
      <title>内核TTY控制台的问题</title>
      <link>https://microcai.org/2010/12/28/ttyproblem.html</link>
      <pubDate>Tue, 28 Dec 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/12/28/ttyproblem.html</guid>
      <description>&lt;p&gt;最近因为编写TTY控制台的UNICODE字体支持补丁，拜读了控制台的代码，诶，妈呀，这个是什么代码哟 &amp;hellip;&amp;hellip;&lt;/p&gt;
&lt;p&gt;TTY 控制台最开始的时候是使用 VGA 显卡的 TEXT模式的。 VGA TEXT 模式有个非常特别的地方就是，显存被映射到了一个固定的位置, 大约接近  1MB 的下方。 两个字节一对。第一个字节指示下一个字节的属性。第二个字节指示一个字符 index. 而这个字符表包含了 255 个字符，在 Windows 中， 这个字符集被称做 OEM codepage, 前127个字符和 ASCII 是一样的. 这样只要向对应的地址写入字符属性和字符的代码，就可以在对应的屏幕位置显示出对于的文字。这TTY 控制台就依据 VGA 字符模式写开了。每个 tty 终端都对应一个结构体。&lt;/p&gt;
&lt;p&gt;这个结构体里有一个 vc_screenbuf 的成员，里面就是按照 VGA text 模式保存的整个屏幕的字符。切换终端的时候，就是一个 memcpy 把这个地方的字符拷贝到显存里，就完成了终端显示的切换。&lt;/p&gt;
&lt;p&gt;问题就出在这里。vc_screenbuf 完全是依据 VGA Text 模式设置的。哪里有地方给你保存 UNICODE 编码啊，只有 255 个字符哦 &amp;hellip;&amp;hellip;&lt;/p&gt;
&lt;p&gt;直接改成  32bit/32bit pair 不就行了？&lt;/p&gt;
&lt;p&gt;NO&lt;del&gt;NO&lt;/del&gt;NO&lt;del&gt;NO&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;不行！ 因为完全和 TTY 无关的别的代码都已经按照现行的结构来写了，这样一改就会大动干戈, 改掉很多很多不是控制台部分的代码。而且，控制台其他部分的代码，也都是直接按照这种格式去操作的，完全没有用宏去封装，改起来难度非常大。&lt;/p&gt;
&lt;p&gt;我曾经花了2天时间去做这种改动。修改了超过一千行代码 &amp;hellip; 结果 &amp;hellip; 还是改不动。
太多地方已经很顽固的假设这种布局了。&lt;/p&gt;
&lt;p&gt;那么，把 字符和属性分开？ textbuf 和 attrbuf ? 其实就相当于重写。
我也花了2天时间这么搞 .. 结果 tty 部分的代码终于改好了，结果发现内核的很多其他部分也要修改 &amp;hellip; &amp;hellip;&lt;/p&gt;</description>
    </item>
    <item>
      <title>内核要集成glibc么</title>
      <link>https://microcai.org/2010/12/24/libcinkernel.html</link>
      <pubDate>Fri, 24 Dec 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/12/24/libcinkernel.html</guid>
      <description>&lt;p&gt;往往内核添加了一个功能， glibc 要花很久才会用上。本来linux 那边为这个功能是否进入内核已经吵半天了，glibc
这边又要为是否使用这个内核新特性再次吵架半天 (glibc 不是 Linux 专有的，还得考虑 BSD (虽然人家也不用 glibc)
SysV Windows(诶，这没办法) ， 还有 sun 那消亡的 *** , 还有, 自家的 Hurd  wink.gif
然后，总之，这样新特性让人的接受上。。。 太慢了。&lt;/p&gt;
&lt;p&gt;说近点的，fnotify glibc还没有对应的包装函数呢，futex 和 NPTL 又是花了许久才进入主流的。libc 是 app
和内核的桥梁，libc 理应快速跟上内核的接口变化 .. 但是 &amp;hellip; &amp;hellip; glibc 和 内核不是一块开发的，所以，这只是理想罢了。
glibc 还要去兼容不同版本的内核呢！
而内核也要去兼容不同版本的 glibc . 双方都背负了太多的历史包袱。glibc 至今保留 LinuxThreads
兼容2.4版本的古老内核。Linux
对已经没用，甚至有bug（接口的问题导致一些bug是必须的）的系统调用也必须保留，随知道用户会用哪个版本的glibc呢？虽然新的glibc
会使用新的调用，但是提供和老的调用一致的 API 来兼容，但是，用户只升级内核而不升级 glibc 是常有的事情. .. 就算升级了
glibc &amp;hellip; 你新版本的 glibc 一定就用上内核的新接口？！？！？！？！ 还是再等几年等 glibc 的开发者吵架结束吧&lt;/p&gt;
&lt;p&gt;于是乎，Linux 的大牛们再次使出绝招： 让 libc 变成 VDSO 进驻内核。&lt;/p&gt;</description>
    </item>
    <item>
      <title>遗忘的语言</title>
      <link>https://microcai.org/2010/12/21/forgottenLANG.html</link>
      <pubDate>Tue, 21 Dec 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/12/21/forgottenLANG.html</guid>
      <description>&lt;p&gt;WEB , 没错，我指的就是 WEB . 但是不是那个用 浏览器堆积起来的 WEB , 而是大师高爷爷随 TeX 推出的 WEB 编程语言。&lt;/p&gt;
&lt;p&gt;WEB 编程语言，让编程顺着人的思路，而不是机器的思路。&lt;/p&gt;
&lt;p&gt;最近为了写论文，也让我有更多的时候去接触 TeX . 突然很想知道现在用的 TeX 是不是高教授写的，还是后人重新实现的 &amp;hellip; 然后去搜寻 TeX 源码 ，终于被我发现， TeX 其实是用 WEB 语言完成的。经处理后变成 PASCAL 代码 + TeX 文档。 PASCAL 代码经 web2c 翻译为 现代 C 程序，然后就可以使用 gcc 编译了。所以，现代TeX发行版里包含的 tex 程序，确实是高教授写的。大师的写程序，居然都是用的不一样的语言啊！&lt;/p&gt;
&lt;p&gt;粗看 WEB 文件，发现除了描述看不到多少代码。几乎都是文档。其实就是思路。 WEB 程序保留了人的思路。完整的保留了人的思维。整个程序的结构也几乎就是安装人的思维去编写的。&lt;/p&gt;
&lt;p&gt;WEB 语言也不限于 PASCAL, 现在有了 CWEB , 就是把 C 结合进 WEB 语言中。GOOD, 有空了试试去。&lt;/p&gt;</description>
    </item>
    <item>
      <title>北京之旅</title>
      <link>https://microcai.org/2010/12/20/tobeijing.html</link>
      <pubDate>Mon, 20 Dec 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/12/20/tobeijing.html</guid>
      <description>&lt;h1 id=&#34;之所以要去北京是因为参加红帽的笔试--废话大家都知道了-讲讲这段五味瓶的日子吧&#34;&gt;之所以要去北京，是因为参加红帽的笔试  (废话，大家都知道了) ，讲讲这段五味瓶的日子吧&lt;/h1&gt;
&lt;p&gt;恩，早上起来打开电脑 &amp;hellip; 发现显示器开不起来 &amp;hellip; 开开关关多次，亮了 &amp;hellip; 以为升级系统导致的显卡驱动问题 &amp;hellip;..
算了，现在没空，能用就行 &amp;hellip;&lt;/p&gt;
&lt;p&gt;然后挂 IRC , 继续调式内核 &amp;hellip; ..&lt;/p&gt;
&lt;p&gt;恩恩，不知道怎么回事，IRC 聊起来红帽的招聘 &amp;hellip; kaio 说某人等了7个月 &amp;hellip; 我说我都等3个月了 &amp;hellip; kaio
问我面试了？ 我说没 .. 我等笔试都等3个月了 &amp;hellip;（ 当时不知道 alexcpio 说的 下月4号的有米有我的份呢） kaio
说，人家是面试后等了7个月 &amp;hellip;&amp;hellip; 我 囧 &amp;hellip;.
然后正要说什么，突然手机dongdongdong &amp;hellip;. wow. 说曹操曹操到，激动啊 &amp;hellip; &amp;hellip;&lt;/p&gt;
&lt;p&gt;接到通知赶紧买票，一查，火车票比飞机票还贵，情何以堪情何以堪啊 &amp;hellip; .. 于是就买飞机票去了&amp;hellip; &amp;hellip;
诶，都是半辈子的积蓄啊，顺便 BS 一下红帽，就不能来杭州招聘啊。&lt;/p&gt;
&lt;p&gt;这行是解决了，住宿呢？旅馆？我过去怎么也得待个四五天的，几百一晚，我不成乞丐了啊&amp;hellip;.
恩，以前听说某人发光是 twitter 结果就免费周游世界去了（顺便 BS 一下这家伙）&amp;hellip; &amp;hellip;
恩，说不定好多童鞋在北京的 &amp;hellip; 兴许能帮忙找个便宜的旅店，抱着试一试的态度发贴求助。
回应的人好多啊 &amp;hellip; 而且给于了我不曾想到的关注和帮助, 让我一个一直被人忽略的人激动得热泪盈眶 .. .. &amp;hellip;
还有童鞋提议乘我去北京，再聚会一次&amp;hellip; 我内牛满面啊&amp;hellip; &amp;hellip;
最后duyue说我可以住他宿舍&amp;hellip; &amp;hellip; 额，免费的？ 恩，应该是 .. 这得节约多少钱啊 .. 偶穷人一个，能省钱就好 &amp;hellip;&amp;hellip;.&lt;/p&gt;</description>
    </item>
    <item>
      <title>修复了三星显示器</title>
      <link>https://microcai.org/2010/12/16/fixsumsumLCD.html</link>
      <pubDate>Thu, 16 Dec 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/12/16/fixsumsumLCD.html</guid>
      <description>&lt;p&gt;诶，出发去北京的前两天，也就是十一月三十日 &amp;hellip; 早上一大早起来开机。我可怜的三星740NW显示器就再也不工作了。
蓝色的电源指示灯快速的闪动着，可显示器就是不给开起来 &amp;hellip;.&lt;/p&gt;
&lt;p&gt;恩，应该是坏掉了，也许问题不那么严重，上网看看有米有什么便捷的方法解决吧！&lt;/p&gt;
&lt;p&gt;呵呵，还好我先见之明 .. 还有一 EPC. ..&lt;/p&gt;
&lt;p&gt;马上开起来 .. 囧。 前些日子为了测试 systemd &amp;hellip; 把系统搞坏了. &amp;hellip; 马上重装！ 于是花了几个小时重装 了 archlinux &amp;hellip;. (额，我 gentoo 控。但是我需要马上用电脑&amp;hellip; gentoo 编译 .. 我了个去，将就着 用 arch 先)&lt;/p&gt;
&lt;p&gt;终于到最后安装上 chrome 了，呵呵。 恩，还没安装 ibus &amp;hellip; 得，不装先， &amp;hellip;&lt;/p&gt;
&lt;p&gt;google 了好些，终于发现很多人也有此症状（对三星的质量先日一下）。 专家说，是 inverter 坏掉了 &amp;hellip;.&lt;/p&gt;
&lt;p&gt;我了个去 &amp;hellip; 这下我自己修不好了 &amp;hellip;..&lt;/p&gt;
&lt;p&gt;诶，得。再买一个去吧 .. 55555555&lt;/p&gt;
&lt;p&gt;既然再买一个，恩恩，这个咱就拆了吧 &amp;hellip; .. 说实话，我老早就想拆它了 &amp;hellip;. (&lt;em&gt;^__^&lt;/em&gt;) 嘻嘻……&lt;/p&gt;
&lt;p&gt;说干就干 &amp;hellip; &amp;hellip; 我蛮力的拆解了这款 740nw &amp;hellip;&lt;/p&gt;
&lt;p&gt;好家伙，LCD 显示器也忒简单了吧！&lt;/p&gt;</description>
    </item>
    <item>
      <title>P2P 终结者 for Linux</title>
      <link>https://microcai.org/2010/11/02/p2pkiller.html</link>
      <pubDate>Tue, 02 Nov 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/11/02/p2pkiller.html</guid>
      <description>&lt;p&gt;很长一段时间，都在渴望一个 for Linux 的 P2P 终结者。&lt;/p&gt;
&lt;p&gt;但是，谁让我们是小众群体呢？所以，没有。&lt;/p&gt;
&lt;p&gt;但是，今天我突发奇想，找到了！用脚本实现了 P2P 终结者！&lt;/p&gt;
&lt;p&gt;问题是这样的，首先我需要一个 arp 欺骗工具。呵呵， dsniff 就是！&lt;/p&gt;
&lt;p&gt;执行  arpspoof 就可以进行 ARP 欺骗了。 不过，呵呵，我只对需要控制的主机进行 ARP 欺骗，比如 192.168.1.100&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;arpspool -i eth0 -t 192.168.1.100 192.168.1.1 
arpspool -i eth0 -t 192.168.1.1 192.168.1.100 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样成功的让 192.168.1.100 到  192.168.1.1 之间的通讯全部通过自己了&lt;/p&gt;
&lt;p&gt;然后，我打开 内核的 IP 转发。
echo 1 &amp;gt; /proc/sys/net/ipv4/ip_forward&lt;/p&gt;
&lt;p&gt;呵呵，现在，怎么限速就是我的事情啦！ 可以使用 tc 限速，也可以简单的时候 iptables 限速！
比如，使用  iptables 的 limit 匹配模块来限速. 一秒钟是能发送和接收 3 个数据包，这样速度就限制到 4k/s 了&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;iptables -A FORWARD -s 192.168.1.100 -m limit --limit 3/s -j ACCEPT          
iptables -A FORWARD -d 192.168.1.100 -m limit --limit 3/s -j ACCEPT                 
iptables -A FORWARD -s 192.168.1.100  -j DROP                                                
iptables -A FORWARD -d 192.168.1.100  -j DROP                                             
&lt;/code&gt;&lt;/pre&gt;</description>
    </item>
    <item>
      <title>一个Sqrt函数再次引发的血案</title>
      <link>https://microcai.org/2010/10/16/somethingaboutsqrt.html</link>
      <pubDate>Sat, 16 Oct 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/10/16/somethingaboutsqrt.html</guid>
      <description>&lt;p&gt;这些神人啊，开平方居然有这么快的算法！！！
于是我决定看看 glibc 是怎么实现的！
如果 glibc 比较慢，我一定要改成神人的算法重新编译 glibc ！！！&lt;/p&gt;
&lt;p&gt;等等！先写一个程序测试两种算法的速度&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;math.h&amp;gt;

float magic_sqrt(float number)
{
    long i;
    float x, y;
    const float f = 1.5F;

    x = number * 0.5F;
    y  = number;
    i  = * ( long *)    &amp;amp; y  ;
    i  = 0x5f3759df - ( i &amp;gt;&amp;gt;  1 wink.gif     ;
    y  = * ( float * wink.gif    &amp;amp; i  ;
    y  = y * ( f - ( x * y * y wink.gif wink.gif ;
    y  = y * ( f - ( x * y * y wink.gif wink.gif ;
    return number * y;
}
#define TIMES 2000000000
int main(int argc, char argv[0])
{
	unsigned int i;
  if(argv[1]==&#39;s&#39;)
  {
    for(i=0;i &amp;lt; TIMES; i++)
    {
	  sqrt(200.0);
    }
  }else
  {
    for(i=0;i &amp;lt; TIMES; i++)
    {
	  magic_sqrt(200.0);
    }
  }
  return 0;
} 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后用 time ./a.out s 和 time ./a.out m 来测验两个开发算法的速度。
哥震惊了！！！ 一样快！！！莫非 glibc 也使用了神一样的 &amp;hellip; ?????&lt;/p&gt;</description>
    </item>
    <item>
      <title>如何避免使用 root 权限调式 libpcap 程序</title>
      <link>https://microcai.org/2010/10/15/debug-libpcap-program-without-root.html</link>
      <pubDate>Fri, 15 Oct 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/10/15/debug-libpcap-program-without-root.html</guid>
      <description>&lt;p&gt;工作原因，经常用 libpcap 写程序。&lt;/p&gt;
&lt;p&gt;可是调式却一直是个大问题。&lt;/p&gt;
&lt;p&gt;即便是非常麻烦地每次编译后 setuid
gdb 也是不能调式 setuid 程序，gdb 会使 setuid 失效。
一直以来的解决办法都是原始的sudo + printf ， 而无法单步调式。实在有时候需要单步了，就 sudo eclipse 启动了
结果调式完毕之后还需要
sudo chown cai:cai ~/workspace -R&lt;/p&gt;
&lt;p&gt;灰常的不爽&lt;/p&gt;
&lt;p&gt;后来发现了 gdb-server&lt;/p&gt;
&lt;p&gt;可以用 sudo gdb-server 启动要调式的程序，再在 eclipse 里选择 gdb/server 作为调式程序。
这样就不必为了调式而整个让 eclipse 启动到 root 环境了&lt;/p&gt;
&lt;p&gt;可是，还是很不爽。每次调式前都要
sudo gdb-server localhost:5000 我的程序&lt;/p&gt;
&lt;p&gt;后来，终于发现，我可以先用 dumpcap 抓取一定的包，然后保存到一个文件中.
只要把原先打开网卡的代码稍微改一下变成
pcap_open_offline
就可以了
而从文件开始读取，可以模拟非常巨大的网络流量，很考验处理程序.&lt;/p&gt;
&lt;p&gt;而通过 有名管道，又可以轻易的支持 在线抓包调式。使用管道的时候经过我的测试，发现必须这样
dumpcap -w - &amp;gt; /tmp/fifo
写才行。然后我的程序就可以把管道作为文件直接打开
发布的时候，代码再改回来，或则干脆就不改，作为一个命令行选项。&lt;/p&gt;</description>
    </item>
    <item>
      <title>GB系列编码 比 UNICODE 先进，是最先进的编码</title>
      <link>https://microcai.org/2010/10/11/gbkrocks.html</link>
      <pubDate>Mon, 11 Oct 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/10/11/gbkrocks.html</guid>
      <description>&lt;p&gt;首先 UNICODE 里头只有 utf8 能兼容 ascii,所以，这已经是 UNICODE 的一大失败了。
接着我们将两个大方面的比较&lt;/p&gt;
&lt;p&gt;一，汉字方面
1.1 汉字编码排列方面
UNICODE 编码中，汉字的排列毫无规律可言。 （0分)
GB 系列编码中，汉字都是依据读音笔画排列下来的。非常的有规律。 (1分)&lt;/p&gt;
&lt;p&gt;1.2 编码效率方面
UNICODE 在实现上，只有 utf8是兼容 ascii的，我们只考虑 utf8
utf8汉字大部分是 3byte编码，少数汉字为 4byte (0分）
GB系列编码中，汉字几乎是 2byte编码，少数汉字为 4byte编码（GB18030标准） (1分)&lt;/p&gt;
&lt;p&gt;二，非汉字部分
非汉字部分就是英语咯，还有欧洲语言，还有特殊字符。其中英语是一样的，不用比较
2.1 非ascii字符集支持
GB系列标准中，欧洲字母也是和汉字一样编入方案的。 (1分）
和 UNICODE 一样支持欧洲字母 (1分）
2.2 其他国家语言，包括繁体中文
GBK 中收录大部分繁体。在新的扩增标准 GB18030中，呵呵，保留了足够的码位来支持全世界的字符。 （1分）
UNICODE 一样 (1分）
2.3 非汉字编码效率
UNICODE 反而对很少用到的字符给比较小的码位，在 UTF8中表现为2byte &amp;hellip;.  (0分）
GB系列编码中，汉字为2byte,常用的他国语言文字也是2byte，其他少用字符的由 GB18030扩展，为 4byte （1分）&lt;/p&gt;
&lt;p&gt;综合起来，UNICODE 就是一垃圾编码，给这个世界带来了混乱，早该废止！！&lt;/p&gt;</description>
    </item>
    <item>
      <title>异步单线程的梦</title>
      <link>https://microcai.org/2010/10/10/async.html</link>
      <pubDate>Sun, 10 Oct 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/10/10/async.html</guid>
      <description>&lt;p&gt;很享受单线程带来的好处。&lt;/p&gt;
&lt;p&gt;第一：不用考虑锁。
第二：不用考虑线程切换开销。
第三：很锻炼人异步并发的思想。&lt;/p&gt;
&lt;p&gt;特别是第三点，我觉得最喜欢了。
非常喜欢异步执行，异步通知。
用一个线程，完成了所有的逻辑。而且不能阻塞在一个逻辑上。如果需要阻塞，就采用异步通知，等它ready了再处理。&lt;/p&gt;
&lt;p&gt;单线程异步并发用的久了
突然有一天碰上了 ALSA &amp;hellip; &amp;hellip; &amp;hellip;
居然再也不能使用了。。。。。。
ALSA 的异步通知只有一种。那就是信号。
但是信号是不可靠的，而且信号数目有限，怎么能用来做异步通知呢？（所以也很讨厌 aio）
ALSA 居然不能方便的时候 poll/epoll 来进行通知，各种事件非得用 alsa_*(会阻塞的) 获得  &amp;hellip;. 逼我用多线程。&lt;/p&gt;
&lt;p&gt;当然，PulseAudio 的话 &amp;hellip; 由于是 socket 连接，可以继续你的异步梦了 &amp;hellip;.. but .. who likes pa ?&lt;/p&gt;
&lt;p&gt;很多地方都可以异步单线程，而且都是使用的 epoll/poll 通知机制, 所以，任何可能会阻塞的地方，如果能使用 poll
那么，永远都不用当心你的梦会破灭 &amp;hellip; (ALSA该死，破灭我一次)&lt;/p&gt;
&lt;p&gt;最后，用 Alan Cox 的名言来打击一下使用多线程的人：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  computer is a state machine. Threads are for people who can&#39;t program state machines. （计算机是一台状态机。线程是给那些不能编写状态机程序的人准备的。）
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;文件IO == 使用 poll/epoll
套接字 == 使用 poll/epoll
Direct IO == 使用 poll/epoll
Timer == 巧妙的编入 polll/eppll 的 timeout 参数
空闲  == 利用 poll/epoll timeout=0
抓包 == pcap_fileno 获得文件描述符，使用 poll/epoll
GUI == 获得 X11 连接的文件描述符，使用 poll/epoll
OpenGL == OpenGL is natively async with GPU , OpenGL 错误被合并入 X11 汇报
文件监视 == 返回的也是文件描述符
Netlink == 返回的也是套接字&lt;/p&gt;</description>
    </item>
    <item>
      <title>简历上的神吹</title>
      <link>https://microcai.org/2010/07/28/fuckingresume.html</link>
      <pubDate>Wed, 28 Jul 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/07/28/fuckingresume.html</guid>
      <description>&lt;p&gt;实习的时候看过几十份求职简历，现在把我看过的简历的特点简单介绍一下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;神吹

     倒不是像唐骏那样撒谎，就是什么东西都写，其实没那么厉害。比如，有个人简历上写自己做过搜索引擎。把人找来一面试，连基本的 C 语言都不会。能吹吧？ 把团队里别人的功劳说成自己的，真 TM 恶，自己不过是一个混班的罢了。这是吹嘘的比较厉害的，还有稍微不厉害点的，比如明明英语基本不会，非说自己过了六级 (这也能写，真逗，参加辅导班过的六级和没有做准备就去考，档次不是一样的。)

 
鸡毛大的事情也当辉煌经历

    比如，考个四六级就当是辉煌了。操，要是有人觉得没什么好写的，就不写，那不是被招聘的人认为是六级都过不了吗？ 操，这些JB。直接导致不写鸡毛事情的人遭殃。

 
学过的就当会的
    这你要是不写吧，人家就觉得你连见识都米有。

都有个名字很好的学位证书。

    嗯，我是主动辍学的，不想继续耗费青春。如果你是个非要看证书的人，请离开。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;简历如海，你们这些投机取巧的人，把我们老实本分的人都欺负了。直接导致用人单位用更高的要求筛选其实要求没这么高的职位。这让老实人只能去做相对其实力要简单很多的职业。 这是对人力资源的浪费。&lt;/p&gt;
&lt;p&gt;好了，讨厌简历的原因写好了，就是说，考场作弊的人太多，坚持不作弊的人还值得去考试么？问题是，考官还不知道谁作弊了！真气人。&lt;/p&gt;</description>
    </item>
    <item>
      <title>关于机翼的升力</title>
      <link>https://microcai.org/2010/07/15/aboutlift.html</link>
      <pubDate>Thu, 15 Jul 2010 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2010/07/15/aboutlift.html</guid>
      <description>&lt;p&gt;科普上，书本上，说升力来自压力差，压力差来自伯努力。
是这样的吗？&lt;/p&gt;
&lt;p&gt;上边的空气为何要和下边的一起到达机翼后沿？这是没有根据的。
升力确实来自压力差，但是压力差并不能简单的解释为流速差带来的。因为这样的话，倒飞就无法解释。&lt;/p&gt;
&lt;p&gt;根据伯努力原理，流体的压力分静压和动压。当流体流向于物体表明一致的时候，表明只能感受到静压，当于表明差垂直的时候，能感受到全部的动压和静压。&lt;/p&gt;
&lt;p&gt;飞行时，机翼的玄线和来流方向有个夹角，这个夹角叫迎角，这时，机翼下方受到了气流的动压。这个动压+静压比上表面的大多了，而且动压远远大于流 速差带来的静压差，所以所，迎角是机翼升力的主要原因。根据柯达效应，此时机翼上表面还能感受到负动压，负动压甚至大于下表明的正动压，所以，机翼的升力 主要是由上表面的吸力贡献的。&lt;/p&gt;
&lt;p&gt;这就是升力产生的原理，可不是什么流速差哦。&lt;/p&gt;</description>
    </item>
    <item>
      <title>For every bug, there is a ugly man</title>
      <link>https://microcai.org/2009/09/28/foreverybugthereisauglyman.html</link>
      <pubDate>Mon, 28 Sep 2009 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2009/09/28/foreverybugthereisauglyman.html</guid>
      <description>&lt;h1 id=&#34;where-is-it-then-for-many-nights-i-cant-sleep-reviewing-very-code-that-acquiring-locks-there-is-no-mistake&#34;&gt;For every bug found in the softwre, there is a ugly man behind.
For too many days! I&amp;rsquo;ve been working on that bug! And the software has already ran in a hotel!
The only way that me can use to debug is using ssh plus vim.
No other way. I cannot use gdb, Because that will let the clients unable to surf online.
My program runs on a Linux router. Hang! Hang! There must be dead locks !
Where is it?! Then for many nights, I can&amp;rsquo;t sleep. Reviewing very code that acquiring locks. There is no mistake.&lt;/h1&gt;
&lt;p&gt;I have to use gdb. Then re-ran my progrm in gdb.
when it stopped response, I interrupt this stupid program. &amp;hellip;.. strike!
The error happens when doing libnet_init() It must not be libnet&amp;rsquo;s bug. &amp;hellip;&amp;hellip;&amp;hellip;
Finally, I knew what&amp;rsquo;s wrong. memcpy() param 3 too lengh , in the other file. and other thread.&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
