https://randomnerdtutorials.com/esp8266-and-node-red-with-mqtt/

昨天有个客户找到我，希望做一个能通过手机用openclaw控制电脑的需求。我就尝试了解了一下，正好最近openclaw的热度很高，趁这个机会我看看到底怎么个事儿。

1. openclaw 介绍

openClaw（原名Clawdbot、Moltbot，后因版权纠纷更改）在短短一个月内突破 190,000+ stars，成为 GitHub 历史上增长最快的开源项目之一。

这款由 PSPDFKit 创始人 Peter Steinberger 通过AI编程打造的本地、自托管 AI 个人智能助手，通过将消息平台与 LLM 、智能体深度整合，有界面，有第三方集成能力，实现了从电脑操作，日程提醒，会议摘要生成到网页操作等的全场景自动化。

产品本着能不用人工就不用人工的原则，它的定位是：适用于任何操作系统的 AI 智能体 Gateway 网关

2. 环境搭建

2.1 安装openclaw

通过官网提供的几种方式来安装openclaw，我这里用的是默认的脚本：

1

curl -fsSL https://openclaw.ai/install.sh | bash

国内用户可能需要用魔法，或者尝试其它的安装方式。

2.2 配置 openclaw

这一步需要配置以下几个内容，按照提示一步步走就行：

• AI 模型提供商（我选kimi）
• Channel（我选了feishu）
• skill（可选，我暂时没选）

配置完成后，最后会提醒你要以什么形式运行 openclaw，这里可以选web-UI，使用起来更直观。我这里选了TUI。因为我是需要配置一个云端服务，不需要可视化界面。

完了后就可以在：http://localhost:18789 看到运行界面了。

2.3 编写IM聊天应用

用 react技术栈写了个聊天应用，接入openclaw的聊天系统。

在会话窗口输入相应的命令电脑会同步出现相同的操作。

此时还不够完美，客户的需求是需要在手机端远程控制电脑。有点想以前喜欢玩的一个梗：我希望你能通过电脑控制挖掘机炒菜。

到今天似乎是真的实现了。

2.4 内网穿透

这一步我们是为了通过内网穿透的形式把服务暴露到云端。我用的方案是 frp。

然后就可以肆无忌惮的通过手机来远程控制电脑了。它不同于以往的远程软件的是：这是真正的用AI来帮你处理电脑上的任务，而不是像以往只是远程圈圈点点。

3. 问题列表

3.1 报错不允许的Origin？

在controlUI里配置白名单。（我猜作者用了 vite）

1
2
3
4
5
6
7
8
9
10
11

"gateway": {
    ...
    "controlUi": {
      "allowedOrigins": [
        "https://demo.jzxer.cn",
        "http://localhost:3000",
        "http://192.168.49.230:3000",
      ]
    },
  ...
}

本文不会让你快乐，但是他会让你：稳、狠、不容易被击垮

1. 前言

在我以前还在读书的时候，都喜欢国内的那种柔性美，觉得帅、酷。但是随着年龄的增长，发现真正能带来成长的，是成为一个够硬的男人。

我很早之前，大约 2020 年左右就开始研究男性力量的内容，其中就有探索男性真正应该有的样子应该是什么样的议题。

国内的娘炮文化，显然很难让我找到这些东西。得亏我在初中就开始了解欧美的流行文化，那时候还是 mj、florida、snopy dogg这群前人。

我就往欧美市场找寻，渐渐的发现欧美文化的底蕴，也找到了在外国人眼里男人应该有的样子。期间我看了大量欧美硬汉的片子，比如：汤姆哈迪、杰森斯坦森、道恩强森、阿尔帕西诺…等等。我开始在他们身上寻找共通点，为什么我会非常能感受他们作为男人在女人心中的魅力？他们做对了哪些事儿？

2. 解析硬汉

我不是来取悦世界的，我是来承担重量的。

看着这句话，表达的内容虽然简单，但是似乎有一种说不出的语言魅力。似乎不需要看到说话的人，就能感觉到说这话的人不好惹。

以下我就以我最欣赏的汤老师作为例子，来列举他为什么就能给人这种感觉，我先列举出他的四个核心特质：

1. 身体体承受性：他肩背很厚实，颈部看着很有力量感，看上去就是那种被人快打死了，还能站起来的人

2. 情绪控制力：内心汹涌澎湃，但是外在极度克制

3. 边缘感和危险感：不讨好、不解释、不急于被理解

4. 内在秩序感：生活里有一套极其清晰的自律系统

简单点总结就是：硬 + 稳 + 不废话

回顾一下汤姆哈迪这年轻时候的放纵就知道，他这种硬，来自于那种人生经过各种千锤百炼的高潮低谷，他经历过：暴力、自毁、成瘾、心理问题种种我们大众认为没救了的点。但是直到有一天清晨他宿醉后在自己的呕吐物堆中醒来，发现这种生活不是他想要的，开始洗心革面，开始让生活步入正轨。这个过程是我们很多人忽略的部分，他最后银幕上的成功，他塑造的那些硬汉形象，都是因为他曾经的经历锻造出来的基本面。可以说，看了他的电影，就基本知道他之前是个什么样的人。而这是我们很多人现在无法做到的。

这也是我为什么推崇人生就应该去体验，去经历。读书很重要，但是只是通过看书，坐在办公室刷手机就觉得自己能达到这个境界是绝对不可能的。跳出自己的舒适区，才能拓展自己的舒适区。

实战才是成长最快的途径。

3. 打造硬汉

我搜罗了一些资料，并结合一些自己的经验，总结了以下3个打造硬汉气质的方向。

3.1 第一阶段：身体层

这是作为以下所有层的地基，人与人之间最基础的还是通过视觉传达气场。有的人一眼就能看出来他是个什么样的人就是这个原因。

这一层我们主要就是健身，而健身的主要的目的是：

• 增强肩背厚实
• 让颈部有力量感
• 保持核心稳定
• 行走的时候有“压地感”

具体锻炼细则的话可以按照自身需求和上面描述的方向调整。

3.2 第二阶段：精神层

可以说 90% 的人都倒在了这里，毕竟人都是有惰性的，并且逃离危险是人的本能，而突破这个思想枷锁的过程确实会让人非常痛苦。但是后期思维方式一旦形成，对人的影响是受益无穷的。

在这个阶段，我们需要摒弃一些行为，并且养成一个新的行为体系。

1. 戒掉软行为：长时间刷短视频(<30m)、无意义社交、情绪化输出（解释、抱怨、辩解）
2. 建立痛苦耐受阈值：每天必须做一件抗拒的事（不舒服、你不想做、你还是做了）

这是气质转换的核心机制，虽痛苦，但必须。

3.3 第三阶段：气质与表达

这个阶段主要是为了形成硬核的语言与行为系统。可以去看一些前文我们提到的那些明星视频。去观察他们的行为举止刻意模仿。

• 语言系统：少解释、少修饰、多陈述事实

硬汉语言=低频、短句、确定性

• 姿态与眼神：肩膀自然下沉，胸腔打开；走路步伐慢半拍；看人时不闪躲，不过度盯着人。

4. 总结

真正的硬，不是没有问题，而是发现自己有问题，承认它，并且不逃避。

我们要做的不是把自己变成谁，而是要把自己锻造成一个：

连自己都不敢轻视的人

但是如果从神经分析学的角度来说。它是一种潜意识的映射。存在一种我表面不在意，但是潜意识里很在意的一些事情。

那是对母亲的一种歇斯底里。

“你不要染头发，你本来头皮就不好。“。“我之前就是因为染了，头上长痘痘”。”你别不听别人说。”

那些所谓的关心的话语，在我这里变成一种控制欲，一种被当成物品的不舒服的感觉。

理性告诉我自己，没啥的只是梦而已，看开一点。

但是仔细想想，为什么会有这样的梦呢？它的契机是什么？它想要表达什么？它是不是我内心的一种反抗在意志最薄弱的时候通过梦境发泄出来了？

还是因为，最近太累了？

不得而知。

但是我会去关心这个状态。它一定不是一个随便生成的东西。

它代表某种含义，或许，解决了这个代表的含义，某些潜意识的碎片也会重新被修复起来。

一直在探索市面上轻量化的个人 AI 模型，但是目前像 ds、chatgpt、kimi…都太过于巨大，训练要求也太过于高，所以一直在找是不是有一款阉割版的模型可以提供给个人普通电脑来使用，并且训练。

有的，兄弟有的。

这就是本文需要介绍的 minimind 模型。

安装

minimind 模型的安装非常简单，只需要安装好 python 环境和相关的依赖即可。

由于 minimind 模型的依赖比较多，所以建议使用 conda 环境来安装。严格按照官方推荐的 py 版本会减少很多不必要的麻烦。

依次执行以下命令：

0. 创建 conda 环境（可选）

如果没有安装 conda 环境，建议先安装好 conda 环境。conda官方网站, 安装结束后运行以下命令：

1
2
3
4

conda create -n minimind python=3.10.16
conda activate minimind

python --version # 查看 py 版本是否为 3.10.16

当然如果你有其它更好的方案，或者想体验这个解决问题的过程，当然也可以跳过这一步。

1. 克隆代码

1

git clone https://github.com/jingyaogong/minimind.git

2. 安装依赖

记住这里需要进入项目根目录下安装

1
2

cd minimind
pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple

3. 下载模型

1

git clone https://huggingface.co/jingyaogong/MiniMind2 # or https://www.modelscope.cn/models/gongjy/MiniMind2

注意：这里有可能 model.safetensors 文件下载失败，这是因为 huggingface.co 上的文件比较大，下载速度比较慢。如果下载失败，建议使用 modelscope.cn 上的模型。或者直接下载模型文件手动添加到当前目录。

4. 运行 web 界面

1
2

cd scripts
streamlit run web_demo.py

此时即可在本地浏览器使用 localhost:3000 访问交互界面。

前期准备需要：

1. asr-pro 核心板
2. DHT11 模块
3. OLED 显示器一个
4. WS2812B 灯带一个
5. 电池模块一个
6. tp4056 模块一个
7. 喇叭一个
8. 咪头端子一个

引脚分配

| 核心板引脚 | DHT11 模块引脚 | OLED 引脚 | WS2812B 引脚 | 喇叭引脚 | 咪头端子引脚 |
| :—: | :—: | :—: | :—: | :—: | :—: | :—: | :—: |
| PB6-TX,PB5-RX | PC4 | PA5-sda,PA6-scl | PA4 | SPK | MIC |

硬件连接如下：

1. 将 DHT11 模块连接到核心板，VCC 接 3.3V，GND 接 GND，DATA 接 PB6。
2. 将 OLED 显示器连接到核心板，VCC 接 3.3V，GND 接 GND，SCL 接 PA6，SDA 接 PA5。
3. 将 WS2812B 灯带连接到核心板，VCC 接 5V，GND 接 GND，DIN 接 PB7。

突然发现好像25版本的多了虾哥的语音模型，就把语音替换成了魅惑女的声音，效果不错。

代码的话存在gitee。

目前有个想法，就是好像可以尝试用这个模块链接esp32-s3，用串口通信实现命令词唤醒识别。
这样就可以自定义学习唤醒词。

只要信念坚定，你会慢慢的向你的信念的方向靠齐，离你认可的成功越来越近。

我和 tz 的认识起源于我发布的一篇小红书，当时由于我在做产品的外观设计，但是由于我的建模能力确实有限，绘制出来的模型实在不敢恭维，但是我们团队如果想要上 ks 众筹的话，外观设计又是非常重要的一环。

虽然我知道我花了一定的时间学习建模知识，水平会有所改善，但是它一定会花费我很多的时间精力，我们团队又需要快速的出一个 demo 原型，来验证这个商业闭环的可行性。然后就发生了开头那一幕，在小红书上我认识了 tz。

7 号晚上 8 点，我和 tz 开了一个线上会议，来讨论关于智能绿植 pico 的产品外观。他是一名工业设计师。而我是一名多年的资深前端工程师，两者的共通之处都是对可视化产品有一定审美。还有一个相似之处就是，我们都对模块化的产品情有独钟。

概念：万物模块化

19 年底，我构想了一个概念，我认为生活中的很多物品，它们都可以相互链接，从而实现万物可模块化。

比如手机嵌入笔记本电脑的中心，是不是就可以作为 CPU 或者 GPU 来使用？

因为我发现，生活中很多的人，他们可能都拥有：一台笔记本、一个平板电脑、一部手机。

而笔记本电脑和手机可能用的是同一个处理器。或者平板电脑和手机用的是同一款处理器。这也就是为什么后来出现了折叠手机，三折叠手机。似乎它们就是在满足这样的一种场景。但是思考的方向不是模块化，而是功能更强。

这带来的弊端就是：成本的提升，和产品过度堆砌带来的丑陋设计。 我一直感觉折叠手机挺丑的！

而模块化设计的巧妙之处在于：每个模块拆分成独立的产品。而每个产品可以通过组合达到不一样的功能。

会后

这次会议结束我有两个很深刻的感触：

1. 一款产品如果想要实现模块化，它需要思考的点很多，也就有很多的工作需要在前期就要确定好，比如主体模块的分发模式、结构设计。如何让模块与模块之间的衔接更自然合理？
2. 如果有目标，就去朝这个目标的方向尝试努力，它可能不会给你想要的结果，但是它会帮你去往你想要的那个目标方向去无限接近。这就是做与不做的区别。

LVGL（Light and Versatile Graphics Library）是一个开源的嵌入式图形库，它提供了丰富的图形组件和功能，可以帮助开发者快速开发出美观、易用的图形界面。LVGL支持多种硬件平台，包括ARM Cortex-M、AVR、ESP32等，并且可以在多种操作系统上运行，包括FreeRTOS、Linux、Windows等。

特点

• 跨平台：LVGL可以在多种硬件平台和操作系统上运行，包括ARM Cortex-M、AVR、ESP32等，并且可以在多种操作系统上运行，包括FreeRTOS、Linux、Windows等。这使得LVGL可以广泛应用于各种嵌入式设备和桌面应用程序中。
• 丰富的图形组件：LVGL提供了丰富的图形组件，包括按钮、标签、滑块、图表、列表等，可以帮助开发者快速开发出美观、易用的图形界面。
• 高度可定制：LVGL提供了丰富的配置选项，包括字体、颜色、主题等，可以帮助开发者根据自己的需求进行定制。
• 高效的性能：LVGL采用了高效的图形算法和内存管理机制，可以在有限的硬件资源上实现高性能的图形渲染。
• 开源：LVGL是一个开源的图形库，开发者可以自由地使用、修改和分发LVGL的代码。

使用方法

使用LVGL需要先安装相应的开发环境，包括编译器、库文件等。然后，开发者可以使用LVGL提供的API来创建和管理图形界面，包括添加组件、设置样式、处理事件等。LVGL还提供了丰富的示例代码，可以帮助开发者快速上手。

示例代码

以下是一个简单的LVGL示例代码，用于创建一个按钮和一个标签：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include "lvgl/lvgl.h"

void lv_example_btn_1(void)
{
    /* 创建一个按钮 */
    lv_obj_t * btn = lv_btn_create(lv_scr_act());
    lv_obj_set_size(btn, 120, 50);
    lv_obj_align(btn, LV_ALIGN_CENTER, 0, -40);

    /* 创建一个标签，并添加到按钮中 */
    lv_obj_t * label = lv_label_create(btn);
    lv_label_set_text(label, "Button");
    lv_obj_center(label);
}

int main(void)
{
    /* 初始化LVGL */
    lv_init();

    /* 创建一个屏幕 */
    lv_obj_t * scr = lv_scr_act();

    /* 创建一个按钮 */
    lv_example_btn_1();

    /* 运行LVGL任务 */
    while(1) {
        lv_task_handler();
        usleep(5000);
    }

    return 0;
}

总结

LVGL是一个功能强大、易于使用的嵌入式图形库，可以帮助开发者快速开发出美观、易用的图形界面。无论是嵌入式设备还是桌面应用程序，LVGL都可以提供丰富的图形组件和功能，帮助开发者实现自己的创意。

参考文档

https://lvgl.io/
https://gitee.com/aHeiDaBai/fluent_ui/blob/master/Fluent_UI/API_DOC.md

U8G2 是一个开源的图形库，用于在嵌入式系统中显示图形。它支持多种显示器和微控制器，包括 OLED、LCD、LED 矩阵等。U8G2 提供了丰富的图形函数，包括绘制线条、矩形、圆形、文本等，并且支持多种字体和颜色。

使用

安装

在 platformio 中使用 u8g2 需要安装 u8g2 的库，可以在 platformio.ini 中添加以下内容：

1
2
3
4
5
6

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
lib_deps = 
    u8g2/u8g2:master

使用

在代码中，首先需要包含 u8g2 的头文件：

1

#include <U8g2lib.h>

然后，需要创建一个 U8G2 对象，并指定显示器的类型和引脚：

1

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

接下来，可以在 setup() 函数中初始化 u8g2 对象，并在 loop() 函数中绘制图形：

1
2
3
4
5
6
7
8
9
10
11
12

void setup() {
  u8g2.begin();
}

void loop() {
  u8g2.firstPage();
  do {
    u8g2.setFont(u8g2_font_ncenB08_tr);
    u8g2.drawStr(0, 10, "Hello, world!");
  } while ( u8g2.nextPage() );
  delay(1000);
}

以上代码将在 OLED 显示器上显示 “Hello, world!”。

参考文档

中文显示：https://blog.jmaker.com.tw/chinese_oled/

大五模型，又称人格海洋（ocean model），从20世纪80年代，它在心理特质理论领域发展起来。在20世纪90年代，该理论确定了五项因素，每项因素可以进一步分为两小项不同的值：

Openness to experience： 经验开放性（创新/好奇vs一致/谨慎）
Conscientiousness： 尽责性（高效/有序vs奢侈/粗心）
Extraversion： 外向性（开朗/活力vs独处/矜持）
Agreeableness： 亲和性（友善/同情vs批判/挑剔）
Neuroticism： 神经质（敏感/紧张vs坚韧/自信）

2. 我的测试结果

总结：开放性：高，尽责性：高，外向性：高，亲和性：高，神经质：低

我们一直在探寻真实自我的路上。

这是来自罗姆（Rohm）的BH1750 16位环境光传感器。由于光线对人类和大多数其他生物都至关重要，因此检测环境中的光照强度是学习使用微控制器和传感器时一个常见的入门项目。我们是否应该调高显示器的亮度，还是降低亮度以节省电能？机器人应该朝哪个方向移动才能停留在光线最充足的地方？现在是白天还是夜晚？所有这些问题都可以借助BH1750来解决。这是一款小巧、功能强大且价格低廉的光传感器，您可以将其集成到下一个项目中，以实现光线的检测与测量。

BH1750 提供16位lux光测量，用于测量光的SI单元使其易于与其他值 (如参考和来自其他传感器的测量) 进行比较。能够测量从 0 到 65k+ lux，bh1750。通过一些校准和先进的测量时间调整，它甚至可以说服测量高达100，000 lux。

传感器往往采用小型封装，BH1750也不例外。不比米粒大多少，这个方便的光感应朋友需要一些帮助，以便人们进行实验，而没有使用表面贴装零件的愿望或工具。我们是来帮忙的封装在我们的Stemma QT外形的PCB上，BH1750 集成了电压调节器和电平转换电路，使其可以与3.3v设备一起使用，如Raspberry Pi，或 5v 设备。

引脚介绍

SCL - I2C 时钟引脚，连接到您微控制器的 I2C 时钟线。该引脚具有电平转换功能，因此可以使用 3-5V 逻辑电平，并且该引脚上带有 10K 上拉电阻。

SDA - I2C 数据引脚，连接到您微控制器的 I2C 数据线。该引脚具有电平转换功能，因此可以使用 3-5V 逻辑电平，并且该引脚上带有 10K 上拉电阻。

ADDR/AD0 跳线 - I2C 地址选择引脚。将该引脚拉高或在背面焊接跳线短路，可以将 I2C 地址从 0x23 更改为 0x5C。

示例代码

//  for help look at: https://github.com/Starmbi/hp_BH1750/wiki//  to speed up the measurements you can change the BH1750_MTREG_LOW = 31//  in the hp_BH1750.h file to a lower value#include <Arduino.h>#include <hp_BH1750.h> //  include the library//stores the first MAX_VAL samples in a array.const unsigned int MAX_VAL = 150; //  for Arduino (low memory)                                  //  const unsigned int MAX_VAL = 1500;  //for ESP8266unsigned int val[MAX_VAL]; //  adjust the value to your free memory on the board.hp_BH1750 sens;void setup(){  //  put your setup code here, to run once:  Wire.setClock(400000); //  uncomment this line if you have problems with communication  Serial.begin(9600);  //Serial.begin(115200);       // try this line for faster printing, uncomment the line above  sens.begin(BH1750_TO_GROUND); //  change to (BH1750_TO_VCC) if address pin connected to VCC  sens.calibrateTiming();       //  you need a little brightness for this}void loop(){  //  put your main code here, to run repeatedly:  Serial.println("***********");  unsigned int t = millis() + 1000;  unsigned int c = 0;  while (millis() <= t)  {    sens.start(BH1750_QUALITY_LOW, 1); //will be adjusted to lowest allowed MTreg (default = 31)    if (c < MAX_VAL)    {      val[c] = sens.getRaw();    }    else    {      sens.getRaw();    }    yield(); //  feed the watchdog of ESP6682    c++;  }  unsigned int readVal = c;  if (readVal > MAX_VAL)    c = MAX_VAL;  // Serial.print(c);  // Serial.print(char(9));  // Serial.println(sens.getRaw());  for (unsigned int i = 0; i < c; i++)  {    //Serial.print(i);    Serial.print(val[i]);    Serial.print(char(9));    if ((i + 1) % 10 == 0)      Serial.println("");    yield(); //  feed the watchdog of ESP6682  }  Serial.println("");  Serial.print(readVal);  Serial.println(" Samples per second");  Serial.println("");  delay(1000);}

参考项目

https://github.com/Starmbi/hp_BH1750

深有体会，七岁那年，老妈问我想要成为什么样的人？我说科学家。这个可能是我们这个年代很多小孩子的目标。

然而我们的本意真的如此吗？问问我们自己的内心，我们是打心眼里希望成为，还是因为看了新闻，电视而去模仿？

随着年龄的增长，其实我的目标一直都在变，想成为画家，是因为素描和漫画很好看很高级。想成为舞者，是因为看到南贤俊跳舞很帅。想学 DJ，是因为打碟看着很帅。想成为游戏建模师，是因为感觉游戏建模师名字听上去就很牛逼。

我一直在寻找，直到现在也在寻找，那件我怀着使命感，想打从心里想要去做的事情。而不考虑任何因素，即使地球毁灭，我也希望是在干这件事情的过程中死去的那样一件事儿。

这个过程很艰难，因为我们活在一个欲望和信息膨胀的时代，似乎每个人都处在既要又要还要的恶性循环中，我也不例外。

每天让自己忙忙碌碌也是，到底是真的有这么多的活儿，还是因为恐惧和焦虑？ 是真的忙，还是装作自己很忙。

我不否认随着年龄增大，我越来越珍惜时间。不去浪费太多时间在不好的人或事儿。但是装作忙碌的忙碌是不是也是一种浪费时间？

曾经的我是一个生活节奏很慢的人。这是我真正的样子吗？还是我伪装成的样子，或者说在二手思维加工后的样子？

这个问题，我需要好好思考一下。

通过提升信噪比，来提升幸福指数吧。（如果遵循二八定律，这个噪应该是 5 小时左右，而 19 小时都应该是信，而我的定义是 3/7）

本文会给你制定一个60天计划来帮助你赚到 $1000.

下面的脑图将告诉你读完这篇文章后你会掌握的内容.

我会尽量让这篇文章简洁明了、毫无赘述。但要明白，心态建议绝非无用之物。信念与清晰的目标先于技能与自信。

如果我絮絮叨叨，那是因为我所写的内容对你而言绝对有必要了解。要是你觉得枯燥乏味，那很可能恰恰是你会跳过不看的部分，而之后没取得成效时你又会为此抱怨。

如果你能赚到1000元，那么你就能赚到10000元。

当这个流程深入你的大脑，并且变得越来熟练，你会越来越快的得到1000元。

你会知道：

• 你不需要大量的听众。
• 你只需要学习1-2个能够得到高回报的技能。
• 你的所有行动都是有累计效应的，没有一步是无用功。
• 如果你坚持下去，你将获得越来越多的1000元。

但首先，有一点需要说明。

如果你是因为想找一种快速点击“给我1000美元”按钮来轻松获利的方法才点进这个视频的，那你很可能会失望而归。

摒弃那种快速致富的心态吧。

如果你想掌控自己的收入水平，那就得创业！就这么简单，无可争辩！

如果你要创业，它所要求的个人特质与朝九晚五的工作截然不同。你要对一切负责。你必须管理好自己、提升自己，并且学会坦然面对创业过程中伴随而来的情绪起伏。

你会遭到拒绝。

你会质疑自己是否应该放弃，回到那种仅仅足够舒适得以生存、仅仅没有痛苦得以维持现状的生活。

看在老天的份上，请下定决心去做那件你知道自己必须做的事，从而掌控自己的生活。

这是你摆脱困境的出路。

以下将是我们准备展开的讨论：

• 在自由职业者和机构所有者云集的世界里，建立受众群体的重要性
• 我们应该说什么和应该推销什么
• 微观技能组合——学习两项高收入技能如何让你拥有一个盈利的未来
• 微营销：今天就开始吸引客户，无需花数月打造产品或服务
• 获取客户的两种方法，让你专注未来60天
• 千元挑战：每天执行的具体步骤，把想法变成生意

这封信相当于一门迷你课程，所以篇幅会有点长。

咱们开始吧。

1. 建立你的数字店铺

你需要在社交媒体创建你的受众群体网络。

这就是商业的第一课：你需要为产品或服务引流。当下，搭建网站或设计标志并非明智之举，不会让你的时间得到有效利用。

你无需一开始就拥有百万粉丝，但我敢保证，未来你会希望自己的受众群体不断壮大。

发送冷邮件和投放付费广告固然不错，但还有更好的方法能达成同样的效果，还能避免最终一无所获。

你可以发送10000封冷邮件，在广告上投入10000美元，可之后这些人该何去何从呢？通过在社交媒体上创作内容来打造受众群体，能让你达成以下几个目标：

• 你能够与关注你的人保持联系。
• 它完全免费，你不需要要太多的金钱和许可
• 你所创作的每一篇文章都能让受众更倾向于购买（你的产品或服务等相关事物）。
• 你可以开发新产品并提高盈利能力。
• 人们追随的是你这个人。你并非受困于某种特定的商业模式或技能。
• 当你的受众规模足够大时，你就可以放下客户委托的工作，或者去创建那家你一直梦寐以求的初创公司了（因为你已经拥有了潜在的客户以及团队候选成员，无需再花费成百上千美元用于营销和招聘）。

话不多说，咱们赶紧设置一下你的社交账号资料吧。

2. 确定你想教什么或者想销售什么？

我之前用过很多不同的方式来教这个内容。

大多数时候，这涉及到创建某种主题树。

这仍然很有用，我鼓励你使用它，但我想让事情变得稍微简单一点。

你即将加入你本就身处其中的细分领域。

回答以下问题，并选择最能满足其中大部分要求的1 - 3个主题：

• 在你的搜索记录和YouTube观看历史中，有哪些有价值的内容呢？
• 你关注的账号都在讨论些什么？你觉得自己的知识水平与他们相近吗？
• 如果你现在要买一本新书，它的主题会是什么？
• 当你购买具有教育意义或有助于行为改善的产品（如计划本、软件或健康补剂，而非新衣服或其他生活必需品）时，你会购买什么？

在生活的大多数领域，成功的关键在于明智地模仿。

我们都会模仿。我们的大脑是由迄今为止我们所接触到的信息复杂融合而成的。

人们往往把商业问题过度复杂化了。

他们觉得如果其他人都涉足某个领域，那这个领域就已经饱和了。

并非如此。根本不是这样。

如果其他所有人都在做某件事，那就意味着这件事有利可图。这意味着人们确实有这方面的需求。

所以，你要做的就是做同样的事情，但要让它在某些方面更具独特性。

我创办的初创公司Kortex并没有什么革命性或全新的东西。

到处都在涌现笔记应用和“第二大脑”类应用的仿品。

让我们脱颖而出的是，基于我们在这个领域积累的经验，我们添加了一些小功能，让产品变得更好了一点点，而大多数人并不具备这样的经验。此外，我们还拥有渠道资源。在未来几年里，与Notion这样的产品竞争对我们来说并非难事。其他应用程序能否与之抗衡就不好说了。

即便我们达不到Notion的水平，我们的团队规模和成本仅为其一小部分，而且我们没有拿过任何风险投资资金，仅凭借我们所涉足的小众市场，仍能实现八位数的年度经常性收入（ARR）。

言归正传。

写下你已阅读过的1 - 3个主题。这些将是你创作内容的灵感来源。

写下你已购买过的1 - 3门课程、模板或产品。这些将是你重新定位产品或服务的起始点。

当你真正开始写作和售卖作品时，你才会拥有那些能让你的创作真正独具你个人特色的想法和反馈。

再读一遍上一句话，并把它牢牢记在心里。

这可不是一句随便写出来、供人遗忘的话。它将决定你整个创作旅程的走向。

3. 创建你的个人资料

一个优秀的社交媒体资料就是一个了不起的个人成就。

若想拥有优质的个人资料图片和横幅，你需要了解设计知识和/或摄影知识。

你需要了解撰写个人简介的文案技巧，这样才能写出吸引他人关注（让人想要关注你）的个人简介。

你需要理解你在个人简介里放的链接所涉及的认知（意识）和转化漏斗（营销漏斗）相关概念。

你需要了解社交媒体和写作，才能创作出一篇有权威性且能获得不错互动量的置顶帖（并且在帖子结尾巧妙引导用户进入销售漏斗的下一步）。

现在，你可别拿这当借口，跑去教程地狱里拖延时间。不，你不需要去学设计、文案写作和营销漏斗之类的课程。你需要快速创建个人资料并开始测试。这才是真正掌握这些技能的唯一途径。课程能帮助你学习测试的方法。而技能是你经过测试和筛选后，为取得最佳效果而形成的一系列方法组合。

以下是做这件事最快的方法：

• 观看1 - 3个关于如何拍摄头像照片或制作个人资料照片的YouTube教程，并跟着制作你自己的头像照片/个人资料照片。
• 根据我们之前讨论的内容撰写你的个人简介。明确你想树立权威的话题领域以及你想要提供的价值主张

我已经为你做好测试了。就用这个简介模板吧。

我撰写关于 [主题] 的内容。**[从你的产品/服务中他们将获得的结果]**。

如果我的主题是效率提升、写作和个人成长，而我想要售卖的东西与写作相关，那么我的简介会是：

我撰写关于效率提升、写作和个人成长的内容。学习将写作发展为高收入技能。

然后，我会链接到我产品/服务的第一个步骤，我们会在“微营销产品”部分详细讨论这个步骤。

要是你觉得自己的个人简介还不够好，那也没关系。别为此担心。就带着现有的简介开始创作内容吧。从整体来看，个人简介并没有那么重要。人们可能只看一两眼就会抛诸脑后。真正能为你带来大量粉丝和销售业绩的是你的内容。你要做的就是创作出足够优质的内容，这样一来，个人简介写成什么样都无关紧要了。

最后，一个引导你创建个人资料的问题：

它看起来像是应该有100万粉丝吗？

如果还没有达成（目标等情况），那么在接下来的6 - 12个月里慢慢改进，直到达成。

即便没有达成（目标等情况），你仍然可以吸引粉丝并获得收入。

4. 微观技能栈

对于一人企业来说，你最终需要学习每一个能让你熟练的运营一家企业的每个技能。

现在，要想开始获得收入，你只需要具备几样东西：

• 一个流量来源
• 一款可供销售的产品或服务

因此，简化这一过程的两项技能是写作和销售。

写作很容易上手。你无需具备设计或视频制作经验，甚至不需要写得有多好，只需要写出有影响力的内容即可。所有社交媒体内容都始于写作（没错，就连视频脚本也不例外）。

销售则是将阅读你文字的人转化为顾客的关键。

让我们来学习这两方面的基础知识。

写作以建立受众

社交媒体内容主要有两种类型：

1. 短帖文

这包括推文、Reels（短视频）、Shorts（短视频）、TikTok视频、Instagram上的帖子，以及任何时长在1分钟以内或者字数少于300个字符的内容。

我在任何平台上最喜欢的一种创作方式是先写一条推文，然后把这条推文复制粘贴到Figma或Canva之类的工具的图片模板中（可以看看我的Instagram页面，了解以图片形式呈现的文字是什么样的）。不，你并不需要在任何短内容平台上发布除文字以外的其他内容来吸引粉丝。

短帖文有助于让你一直留在人们的视线中，吸引受众，并测试创意。

短帖文是基础。你每天至少应该发布一条。在X平台（原推特）上，你可以一天发布2 - 3条，以此测试哪些内容适合发布到其他平台，或者可以改编成长帖文。

2. 长篇帖子

这包括X平台上的推文串、Instagram旗下Threads应用上的推文串、Instagram轮播图、领英上的长篇帖子或轮播图，或者我称之为“微型文章”的内容，这类内容近期表现相当不错。

以下是一个“微型文章”的示例：

无论是发布短文还是长文，图片的美妙之处在于你可以将其发布到任何平台。只需确保图片的尺寸为4×5，这样就能适配Instagram。

长文具有策略性。如果基于一个经验证的主题（比如你最优质的短文之一），长文极有可能爆火。它们往往能吸引更多粉丝关注。

问题是，写长文需要花费更多时间。你每周应争取创作1 - 2篇长文，并确保能将其分享出去，这样它们就有机会被更多受众看到。不要依赖算法来助力你实现增长。阅读我的文章《如何从零粉丝开始打造受众群体》，学习相关方法。

确保你社交网络中的每个人都每周分享你的长篇帖子。这就是你实现增长的方式。

你还可以在我时长两小时的写作课程（附有模板）中学习整个流程。

总结如下：

• 每天在X平台发布2 - 3条简短帖子。
• 每周在X平台发布1 - 2条长帖子。
• 当你的粉丝数量达到5万以上时，再考虑开始在其他平台发布内容。

为什么选择X平台？

除了YouTube之外，X平台上的人素质比大多数其他平台的人都高。

人们登录Instagram、领英（LinkedIn）或TikTok并不是为了接受教育。

X平台有点像Reddit，但没那么“有毒”，而且你可以关注真实的人。

你经常上Reddit是为了学习一些你之前不知道的东西。

而且，在X平台上，你只需要把自己的想法写出来就行。

接着，选出你最棒的想法，让在其他平台上的发展变得更轻松。

将一个想法变成一条推文串（thread），再把推文串变成时事通讯，时事通讯变成YouTube视频，视频变成免费下载资料，免费下载资料再转化为一款产品。这就是验证一个好想法的过程。

那么，你实际上要写些什么内容呢？

选取你之前选定的主题，然后按照以下步骤操作：

1. 将这些主题分解为常见的痛点，并阐述如何解决这些痛点。
2. 借助TweetHunter X侧边栏这类工具，研究其他账号的热门推文，然后从你自己的视角对这些推文进行改写。
3. 阅读书籍，并将社交媒体当作记录笔记的平台——但在撰写这些笔记时，要包含引人入胜的开头、正文和结论。
4. 找到你喜欢的YouTube频道，筛选出其中最热门的视频。然后，以这些视频的标题为切入点，创作你的推文开头和帖子内容。

现在，开始写作吧。

5. 销售流程

销售就是讲故事。

你要向对方展示他们能够抵达的未来图景，让他们意识到当前处境存在的痛点，并为他们提供一条从现状（A点）迈向理想状态（B点）的路径。

• 痛点
• 期望达成的结果
• 实现目标的路径（最好是你的独特方法）

这就是销售的本质。

这也是内容的本质。

这也是官网的本质。

所有优秀且有说服力的事物皆是如此。这不仅仅是一堂关于销售技巧的课程，更是如我们上周所讨论的那般，是关于说服艺术的一课。

在你所处的每一种情境中都去实践销售之道，无论是写作、与人交谈，还是努力获取收入之时。

我们不会深入探讨像销售电话这类流程的细节，因为说实话，你无需为此担忧。

作为一名创作者，你90%的“销售”工作是通过内容来完成的：

• 让人们意识到他们的问题/痛点；
• 为他们提供可尝试和试验的解决方案；
• 描绘出他们未来的生活图景，让他们拥有理想的结果。

大多数企业主并不具备打造受众群体所带来的种种便利条件。

在下一部分中，我们将探讨一种更实用的营销方式。

6. 微服务

核心要点：

微服务是一种在你尚未搭建任何实际业务体系时即可开展的服务。

你只需具备以下条件：

• 一个社交媒体账号作为你的公开履历。
• 能够展现你专业权威的内容（通过阐述问题并给出解决方案，也就是“提供价值”）。
• 与点赞、评论、分享你帖子或向你私信提问的人进行沟通的能力。
• 若你未主动联系对方，可让他们填写一份问卷以表明兴趣。

微服务是一种在投入时间将其发展为成熟产品或服务之前，用于测试业务方向的有效方式。

创建微服务的最佳方式很简单：

推出一组为期 4 周的一对一服务套餐，售价 1000 美元。

这能起到以下几个作用：

• 1000美元是个合理的价格。如果有人愿意支付这个价格，那就意味着根据你的目标受众（企业家和商业人士通常对这样的高价不会退缩……只要真的想买，大多数人都能负担得起1000美元，此刻别让限制性信念和你缺乏经验的想法占据上风），其他人会愿意为一个更完善的方案支付3000 - 10000美元。
• 每周进行4次沟通足以让你的客户取得成果。
• 只有少数人能从你为他们代劳的工作中受益（自由职业工作）。但任何人都可能从你在沟通中给予的指导中获益。如果你愿意，你可以将其称为辅导或咨询。
• 在售出几套这样的服务后，你就能确定一份完整产品或服务应该包含哪些内容了。

那么，这4次沟通中具体要包含哪些内容呢？

7. 微服务框架

我们需要一个切入点

你自信能够完成的事情。

步骤1：找出一个重大问题

结合你有相关经验的主要话题，人们面临的一个重大问题是什么？

你可以通过以下几种方式来寻找：

• 撰写关于不同问题的内容，看看哪个问题能获得最多的互动量。
• 研究关于该话题的YouTube视频，找出浏览量高的视频，并观看这些视频以明确它们所针对的问题（所有内容都是为了解决某个问题而创作的）。
• 关注那些讨论该话题的社交媒体账号，看看他们发布的与问题相关的内容中，哪些表现最佳。

重大问题通常属于健康、财富和人际关系这三大永恒市场领域。你的任务是选定其中一个领域，并围绕它来确定自己的兴趣方向。

如果我的兴趣是提高生产力，那么一个重大问题就是人们没有足够的时间或精力让配偶感受到爱意（涉及人际关系），同时在事业上取得进展（涉及财富）。

你可以进一步深入探究，阐述这些问题会给人们的生活带来怎样的影响。就这个例子而言，他们的夫妻关系可能会变得平淡乏味，进而引发不必要的压力，各种小问题不断累积，最终导致精神上的混乱。你越能清晰地描绘出这些问题对人们生活造成的影响，效果就越好。

（将上述内容用于创作相关内容。）

如果我的兴趣是编程或写作，一个大问题就是缺乏一套能让你赚更多钱的技能。你会被学校体系慢慢引导进入一份与你的技能储备无关的职业。这条道路会消磨你用生活做更多事情的精力，还会让你因各种责任而被束缚。

注意，我不仅是在阐述问题，还在放大这个问题。这一点很重要，或许是你撰写营销邮件、着陆页文案以及各类内容时最重要的部分。

不要把问题仅仅看作与你所选的主题或兴趣直接相关的事情。

问题其实是人们生活中已经存在的痛点，而你的主题或兴趣能够解决这个痛点。

在生活中，人们面临的一个大问题是什么？你的兴趣如何帮助解决这个问题？

步骤2：描绘理想的生活方式

与上述问题相反的情况是什么？

他们想要实现的目标是什么？

一旦实现目标，他们的生活会是什么样子？

写下他们理想一天中的 3 个方面。

对于像提高生产力这样的事情，可以这样做：

• 起床后做自己喜欢的工作；
• 午后不再感到疲倦和困乏，以便能够高效工作；
• 安心入睡，不用担心有一堆积压任务带来压力。

如果你愿意，还可以列出更多类似内容。

步骤3：打造独特流程

那么，你实际提供的服务是什么呢？

在课程中，你会引导学员完成哪些事项呢？

最终，你能否将其转化为产品或成熟的服务呢？

你需要一套属于自己的、独特的流程或体系，并且能够持续对其进行优化。

就我的“2小时写作课程”而言，这个体系就是“三点内容生态系统”。

你是如何想出这个体系的呢？

• 把某人从第一步（面临的大问题或者他们当下的状态）迈向第二步（理想的生活状态）所需经历的每一个步骤都写下来。
• 审视这些步骤，对它们稍加润色。打造一个你认为对你所帮助的人有效的体系。
• 为这个流程取一个吸引人的名字。这能激发潜在客户内心的渴望。我创造过许多这样的名字，它们为我带来了如今这样的受众群体，比如“一人企业”“四小时工作制”“精通之道”等等。我通过在大部分内容创作中练习命名（这个内容的名字是“微创作者”，我敢打赌你们中的大多数人正是因为这个名字才关注我的）。

步骤四：别把事情弄得太复杂。

在与客户的4次会面中，你要把写好的步骤进行拆分，让它们能在4次会面内完成。

作为额外的福利，你可以为客户创建一个项目，引导他们完成这些步骤（比如一份生产力规划表、健身计划、撰写新闻通讯或者编写一个小程序）。

这是你提供的服务：

• 解决问题
• 期望的效果
• 独特的流程来弥合差距

当你与人合作时，你应将重点放在优化你的产品/服务（offer可理解为提供的产品、服务等）以及收集客户评价（推荐信、证明）上。

8. 创建一份筛选调查问卷

我们的大多数客户都将通过内容渠道而来。

但是，我们需要一个地方让人们表达与我们合作的意向。

通常情况下，这会是一个着陆页，甚至是一个能展示你产品或服务的完整网站。

不过现在，先别考虑这些。目前这并非必要之举。

注册使用JotForm、TypeForm，或者使用谷歌表单。（国内可是使用番茄表单）

将表单名称命名为“与我一对一合作”。

将表单描述写为“实施[你的独特流程]”。

添加与你的服务相关的问题，具体如下：

• 姓名
• 电子邮箱
• 社交媒体账号（这样你就能联系到他们）
• 你目前面临的最大难题是什么？（设置与你的主题和服务相关的多项选择题答案）
• 你希望30天后自己处于什么状态？（设置与你的主题和服务相关的多项选择题答案）
• “这不是一项免费服务。你是否真心想和我一起实现[期望的结果]？”（设置“是”或“否”的选项）

问题要简短明了。

第 4 个问题能让潜在客户意识到自身存在的问题。

第 5 个问题能激发他们改变的欲望。

第 6 个问题能在他们心中埋下付费合作的想法。

你要把这个问卷放在你的内容下方以及个人简介链接里。

那之后我们该怎么做呢？对于那些没有填写问卷的客户，我们又该如何争取到他们呢？

9. 私信的艺术

当你开始观看线上商业教程时，几乎总会有人建议你通过陌生邮件（cold email）或者给陌生人发私信（cold DM）的方式来为某项你几乎毫无经验技能招揽客户。

而我们现在已经有了一个至少你对其有一定了解的“产品”（此处“offer”结合语境推测为某种产品、服务或业务机会等 ）。

现在，我们需要给那些已经喜欢你、想和你交流，并且有可能成为你潜在客户的人发私信。

避免给随机的人发消息。否则你很可能会在私信和动态里被怼得很惨。

你要给谁发私信呢？

• 那些在你与“产品”相关的帖子下评论的人；
• 那些转发或分享你与“产品”相关帖子的人；
• 那些先主动给你发私信询问问题或者说“嗨”的人；
• 那些填写了你筛选问卷的人。

在我们了解私信里该说什么之前，先来弄清楚什么是“磁性内容”（Magnetic Content）。

磁性内容指的是篇幅或长或短的帖子，这些帖子围绕痛点、益处、理想生活方式、实用小贴士、对常见建议的个人见解、对其他账号高热内容的改写，以及克服痛点的可行步骤等内容展开……所有这些都与你的“产品”相关。

一旦你确定了“产品”，围绕它创作内容相对来说就会比较简单。

评论或分享这些帖子的人，是表达了对相关话题感兴趣的人。向他们发出热情的邀约再合适不过了。他们已经认识你，并且认为你在某方面有一定权威性。

（顺便说一下：如果你是在YouTube上开展这项工作，你无法直接给这些人发私信，所以你需要告知大家填写筛选问卷，然后通过电子邮件联系他们，或者在Instagram等平台上给他们发私信。）

10. 那么，你在直接消息里该说些什么呢？

1) 接着之前的话题继续交流。

如果他们评论或分享了你的一篇帖子，把这篇帖子的链接发给他们，并在私信中“回应”他们的评论。

如果你是在他们填写了你的问卷后通过私信联系他们，你的任务是简要地再和他们过一遍问卷里的所有问题。

开头可以这样说：“嘿，[姓名]，我看到你提交了与我合作的申请表。能和我多说说你为什么填这份表吗？你想通过和我合作获得什么？”

2) 询问他们目前相关事情进展如何。

假设他们对所互动帖子的主题感兴趣，问问他们是否正在学习相关内容，或者进展情况如何。

以健身为例，你可以问：“减肥之旅进展得怎么样了？有没有我能帮上忙的地方？”

这既能让他们想起自己理想的生活方式，又能让他们意识到自己遇到的困难。

如果你是在回复他们的问卷，问问他们为解决所列出的问题采取了哪些措施。

3) 给出新颖的建议并提及你的服务。

到这个时候，你应该已经知道是否能帮到他们了。

1. 先提供一些免费的价值内容与知识教育。这能证明你的专业权威性。

针对他们在第二步中提到的内容给出建议，并且尽量让建议不那么基础。就拿健身或提高效率来说，如果只是告诉他们“多喝水”，他们会觉得你不值得合作。要证明你确实有真本事。

在消息结尾处，提及“实际上我提供一套4次课程来帮助解决这个问题。我会帮你实施[你的独特流程]，简单来说，就是让达成[期望结果]变得稍微容易一些。这4次课程的总费用和一位优秀私人教练的收费相当——1000美元。”

如果你是在回复他们的问卷，就把最后一段换成说明你提供服务的下一步流程。你可以提到，如果他们感兴趣，你会告知每次课程要讨论的内容、如何安排通话、他们需要完成的项目，同时附上一张1000美元的发票。

没错，直接报出价格。

2. 处理异议，发送发票。

销售电话或许能起到帮助，但并非必需。如果他们要求通过电话详细沟通，那就有必要进行一次通话。

刚开始你可能会收到很多拒绝。这很正常。创业初期就是如此。

请记住，我们的目标是在60天内赚到1000美元。在你获得第一个客户并获得客户评价后，这个目标会更快实现。

到这一步时，解答他们提出的任何问题。

等他们问完问题后，给他们发送一个包含Stripe（斯特里普）或贝宝（PayPal）支付链接的发票。

11. 60天行动计划

你会感到困惑和不知所措。

当你学习新事物时，情况本就如此。

你的大脑正在努力拓展和成长，就像举重后会肌肉酸痛一样。

大部分成果会在第30天之后显现。

要是你还没有取得什么有价值的成果，你可能还没意识到，这里存在着一道自然筛选机制，会筛掉那些并非真心想做这件事的人。

在我发布的80个YouTube视频里，只有一个视频火了之后，我才真正感觉自己的YouTube频道开始发展起来了。

对于所有值得拥有的东西而言，一开始往往毫无动静，而后一切都会发生。

你感觉自己毫无进展，可随着经验的不断积累和沉淀，终会有人给出“同意”“认可”这样的回应。

接下来说说该重点关注什么。

不管你是否能立刻取得成果（有些人会），别再沉迷于即时快感，给自己留足60天的时间去赚到第一笔1000美元。

11.1 创建个人资料后，就别再为此忧心忡忡了。

不，修改个人简介并不会让你神奇地每月赚到 1 万美元。

创建好你的个人资料，然后就抛诸脑后吧。

模板：

—————————————————————————————————

我痴迷于探寻无意义事物背后的意义。

我谈论人类潜能相关的话题：

• 生产力、专注力与心流状态

• 哲学与灵性

• 在平凡中发现乐趣

生活方式设计：

• 工作流程优化

• 少工作多赚钱

• 习惯养成、日常安排与持续改进

以及个人创业：

• 创作者、教练和独立创业者

• 内容创作体系

• 现代营销与销售

• 免费社交媒体流量

如果你对以上任何内容感兴趣，就跟着我一起探索吧。

下面简单介绍一下我自己：

我为那些收入达六位数甚至七位数的创作者和网红担任品牌顾问。

当他们想从无人问津的“苦命艺术家”变身成为备受赞誉、收入颇丰的网络红人时，就会来找我。

我帮他们优化工作流程、营销策略和内容创作，让他们每天只需工作两小时，就能收取更高的费用，并让产品和服务实现自动化销售。

我之所以能做好这份工作，是因为我会先在自己身上实践各种方法，清楚哪些可行，哪些不可行。

正因如此，我打造的个人品牌在各平台上的粉丝总数已超过260万（补充说明一下，这是我更新这份简介1.5年后的数据，而我在撰写此前那些文章时，粉丝数才15万多）。如今我平均每天只需工作2 - 4小时，还搭建好了能让创意收入持续流入的系统。

（说这话可能有点像在自夸……但我愿意承受这样的“指责”，好让你不用担心把时间和精力浪费在一个陌生人身上。）

不过，我会始终秉持尽可能透明的原则，对此我绝不道歉。

下面是我的一些作品：

我的文章：https://thedankoe.com/blog

《The Koe Letter》：https://links.thedankoe.com/#letter

我的网站：https://thedankoe.com

如果你还想了解更多，可以在所有社交平台上搜索 @thedankoe 找到我。

或者查看我个人资料置顶区域的链接。

很高兴你能来到这里！】

————————————————————————————————

11.2 每天发布 3 - 5 条简短帖子。

通常我建议每天发布 1 - 2 条简短帖子，这也是我实际的做法。

你可能会觉得每天发 1 - 2 条帖子更容易，但其实并非如此。想法会催生更多想法。你写得越多，就会有更多灵感，学到更多东西，并且会感觉自己取得了更多进展。

以下是具体做法：

• 开始建立一个收藏夹，收集你喜欢并想要借鉴他人的内容（保存优质的推文、帖子、视频等）。
• 在浏览内容、收听播客、阅读书籍或者与人交谈时，随时记下想法。
• 围绕你的产品或服务，撰写关于遇到的困难、解决方案、操作指南、分析解读、对不同意的建议发表评论等内容。

我用 Kortex 来完成上述所有操作。我会在下周的 YouTube 视频中展示我的设置——或者你可以阅读上周的视频来了解具体流程。

每天记得查看你的评论和转发内容，并给相关人员发送私信。

Every day or every other day, include a link and call to action to your questionnaire to have more interested people to DM.

11.3) 每周撰写1 - 2篇长文。

你吸引读者注意力的时间越长，就越能赢得他们的信任，也能提供更多价值。这就是我写长篇时事通讯的原因。人们不需要额外的理由来参加我的课程或试用Kortex（产品名）。

时事通讯并非“微创作者”工作流程的一部分。等你把其他方面都安排妥当了，再加入时事通讯这一项。在“一人创业启动计划”中，我们会详细讲解所有这些内容。

对于长文创作，你可以这样做：

• 选取你最出色的文章（或者其他人的优质观点），然后通过推文串（类似长微博的形式）、微型文章（示例）或者长文对其进行拓展。
• 利用额外的篇幅分享更多独家秘诀。尽量包含至少一条并非普遍建议或常识的内容。
• 在每篇文章的底部插入你的调查问卷链接。

我个人建议撰写推文串。推文串是由多条相互关联的推文组成的。你之前肯定见过，就是一条接一条的推文评论形式。

这种形式因其结构特点更能吸引读者的注意力（更易读），能直接引导读者进行行动呼吁（促进销售），而且可以轻松改编成YouTube视频、Instagram图片轮播或者领英图片轮播。此外，其中的每条推文都可以单独提取出来作为新的推文发布。

长文将是你实现增长和提升销量的主要助力，别忽视它们。

但是，只有有人关注到你的长文，它们才有意义。

11.4）让你的帖子获得关注

在这封信里我没怎么提及这一点（因为我在其他信里已经说得够多了），但算法不太可能让你一夜成名。

大多数人没有意识到，社交媒体上的粉丝增长需要付出实际努力并具备相应技巧。一旦你明白了这一点，就不会再把它看作是只属于网红的运气游戏了。

你需要回复大号和小号的动态。

你需要通过私信与他人交朋友，共同成长。

你需要创作能@其他人的推文串（threads），这样他们就有理由转发你的内容。

你可以在《零粉丝基础打造个人影响力》中学习到所有这些方法。

任何告诉你不需要做这些事的人，很可能只是在向你提供一种不真实且迎合算法的方法。

如果你想随心所欲地创作内容、自由表达想法，算法大概率不会青睐你——或者你运气好，赶上一波流量红利，可当平台规则改变时，你就会纳闷为何自己不再有增长势头了。

11.5）规划你的微服务产品（或微套餐）

你目前还不需要一个完全成型的产品或服务。

你只需要打造这样一样东西：

（1）你在某方面能力高于平均水平；

（2）它能帮助人们切实解决生活中的某个问题。

想想自己擅长什么？

其他人是否想学习这项技能？他们是否已经在学习相关内容了？围绕它是否已经形成了一个行业？你是否关注那些靠此谋生的人？

太棒了，你已经具备了创办一家价值百万美元公司所需的一切。这可不是开玩笑。你正在亲身经历一场关于人们如何赚钱的现场教学。

我写这些时事通讯可不是毫无缘由的。没错，我很喜欢写这些东西（不然我会去做更有利可图的事），但我写它们是因为这对我的业务盈利有帮助。

你所阅读的每一篇文章、访问的每一个落地页、读过的每一封邮件、看过的每一本书等，背后都有经济收益关联。

你之所以没赚到钱，是因为你没有去创作并销售这类东西。

当下，你所需要的仅仅是一套包含4次咨询服务的套餐，售价1000美元，用来教别人一些能让他们生活受益的内容。

健身、一项技能、营养搭配、训练计划制定等等。

选一个领域，主动为人们提供相关帮助。

一旦你开始取得成果，并且清楚人们的需求，那就投入更多时间去打造一家“真正的”企业。

11.6）每周发送30条私信。

这个数字听起来很多，但实际上非常少，甚至有点可怜。

那些每月发送数千封冷邮件的自由职业者和机构负责人，要是听到你抱怨每周只发30条消息，估计都会嗤之以鼻。

不过，每周30条私信，乘以8周，就等于210条私信。

你只需让不到0.5%你联系过的人接受一份价值1000美元的提议就行，这完全有可能实现。

但你可能没意识到的是，即便你只拿下一个客户，你也已经建立起了庞大的人脉网络。

你与210个人有了直接联系。你的粉丝数量可能也增加了几百人。大约有1000人会了解你的专业能力。他们每个人又认识50到500个可以帮你宣传的人。

你坚持得越久，就会有越多的人表示同意，你的受众群体也会不断壮大，很快就会有人主动找上门来与你合作。

最近在学习如何从0到1生成一个自己独有的AI模型，主要是对未来市场的观望：

在未来，每个岗位都有一个独有的AI模型作为辅助，类似assistant的存在，它可以以宿主的思维来帮助解决大多数杂糅重复的工作。

那么如何训练这样的专有模型，就是一件非常值得深入了解的事情。

探索

目前我了解到市面上有两个模型管理平台，类似github管理代码一样，一个是：Ollama、一个是Huggingface。

而Ollama有自己的客户端可以使用，并且界面看上去更加符合我的审美，虽然 huggingface看上去更加庞大点儿，它们的区别就像facebook和Instagram，很遗憾，我喜欢Instagram，所以我选择了 Ollama深入了解。

训练步骤

1. 下载Ollama客户端

进入官网 Ollama下载适合自己的客户端文件。并且安装。

2. 按提示安装 model

在安装完之后，ollama会提醒用户执行两个操作：一个是全局安装 ollama 命令行工具、另一个是安装 llama3.2 模型。我们按步骤执行即可。

3. 安装想要的model

因为本篇文章目的是训练 deepseek-R1 模型，所以我们可以进入官方模型页面进行下载：我这里选择的是 5b蒸馏版本。

ollama run deepseek-r1:1.5b

4. 微调前的准备

这一步需要执行两个步骤，一个是把ollama服务跑起来，另一个是创建训练任务。

1
2

ollama serve   // 运行服务
ollama create my_finetuned_model --base deepseek-r1:1.5b --data /path/to/data.txt        // 创建微调模型任务

my_finetuned_model：微调任务名称

/path/to/data.txt：微调模型保存路径

5. 开始训练

开始训练上文创建的训练任务

1

ollama train my_finetuned_model

• Ollama 会自动处理模型的加载、数据的读取和训练过程。
• 训练过程中，你可以通过 Ollama 的日志查看进度。

6. 模型评估

在训练任务结束之后，我们可以通过以下命令来测试训练结果是否符合预期,如果结果不理想的话可以调整训练参数，如：学习率、训练轮数等，然后重新训练。

1

ollama run my_finetuned_model "Your test prompt here"

7. 保存并导出模型

由于平时使用的场景 tensorflow偏多，这里就以 SavedModel 格式或 Keras 模型格式作为范本来讲解。

a. 安装必要的依赖库

1

pip install tensorflow tensorflowjs

b. 导出脚本编写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import torch
import tensorflow as tf
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载 PyTorch 模型
model_name = "my_finetuned_model"  # 替换为你的模型名称
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 将 PyTorch 模型转换为 TensorFlow 模型
model.eval()  # 确保模型处于评估模式
example_input = tokenizer.encode("Your example input text here", return_tensors="pt")
example_output = model(example_input)

# 使用 TensorFlow 的 `tf.keras.Model` 构建等效模型
# 注意：这一步可能需要根据具体模型结构进行调整
input_ids = tf.keras.Input(shape=(None,), dtype=tf.int32, name="input_ids")
attention_mask = tf.keras.Input(shape=(None,), dtype=tf.int32, name="attention_mask")

# 构建 TensorFlow 模型
tf_model = tf.keras.Model(inputs=[input_ids, attention_mask], outputs=model(input_ids, attention_mask=attention_mask))

# 保存为 TensorFlow SavedModel 格式
tf_model.save("/path/to/save/tf_model")

c. 将tensorflow模型转换为 tensorflowjs模型

使用 tensorflowjs_converter 工具将 TensorFlow SavedModel 转换为 TensorFlow.js 格式。运行以下命令：

1

tensorflowjs_converter --input_format=tf_saved_model /path/to/tf_model /path/to/tfjs_model

8. 在tensorflowjs中使用导出的模型

a. 在浏览器中运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

... more code
<script>
    async function loadModel() {
      const model = await tf.loadGraphModel('/path/to/save/tfjs_model/model.json');
      console.log("Model loaded successfully!");

      // 准备输入数据
      const input = tf.tensor([[1, 2, 3, 4]]); // 替换为实际输入数据

      // 运行模型
      const output = model.predict(input);
      console.log("Model output:", output.dataSync());
    }

    loadModel();
  </script>
... more code

b. 在nodejs 中运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

const tf = require('@tensorflow/tfjs-node');

async function loadModel() {
  const model = await tf.loadGraphModel('file:///path/to/save/tfjs_model/model.json');
  console.log("Model loaded successfully!");

  // 准备输入数据
  const input = tf.tensor([[1, 2, 3, 4]]); // 替换为实际输入数据

  // 运行模型
  const output = model.predict(input);
  console.log("Model output:", output.dataSync());
}

loadModel();

参考文档

https://ollama.com

在使用 platformIO 的时候，有的时候涉及到敏感信息，我们并不希望把程序源码开源，但是希望能给用户上手体验，这个时候.bin 烧录程序就很有用.

下面简单介绍一下具体的操作步骤。

生成 .bin 文件

在 platformIO 下，一般在调试打包上传的过程中，会自动生成.bin 文件。如果没有生成，点击如下按钮，先生成bin 文件。


如果打包构建成果的话，以我创建的 esp8266 程序为例，它就会在如下目录位置生成 .bin 文件。


然后就可以通过更改名称来创建想要的烧录程序的版本了。

烧录 .bin

既然我们生成了 .bin 文件，下一步当然就是使用它。目前有两种方式，一个是用 platformIO 烧录，一个就是用esptool.py。我这里只介绍后者。

1. 下载 esptool.py

如果电脑有 brew：

1

brew install esptool

如果没有，执行：

1
2
3

pip install esptool
// or
pip3 install esptool

2. 烧录

这一步是把打包构建好的 bin文件烧录到对应设备里去。

首先进入 .bin 所在的文件夹内，执行以下命令：

1

esptool.py --port /dev/tty.usbserial-XXXX write_flash 0x1000 firmware.bin

• tty.usbserial-XXXX 这个指的是你的设备对应的端口号
• 0x1000 是大多数 ESP32 项目中默认的启动地址。对于不同的项目或开发板，可能需要调整这个值。

在烧录过程中，esptool.py 会显示进度条和烧录信息。完成后，开发板会自动重启，加载新的固件。

小结

使用 bin 的好处就是防止不必要的源代码外泄，进一步提升自己隐私的安全性。当然这个功能可能在商业上应用场景更多一点。

蓝帽电位器，便宜好用的传感器，可以用来调节 PWM 占空比，调节 LED 亮度，调节蜂鸣器音量等等。

引脚连接

这个传感器的结构特殊，起到关键作用的是中间那个引脚。

代码示例

本案例使用的是 STM32-F103C8 开发板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int pwmPin = PB6;
int ledPin = PB7;

void setup() {
  Serial.begin(115200);
  // 设置 PWM 引脚为输出模式
  pinMode(pwmPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int data = analogRead(pwmPin);
  int pwmValue = map(data, 0, 4098, 0, 255);  // 将 sensorValue 映射到 0 - 255 的范围
  Serial.println(pwmValue);
  delay(100);
  analogWrite(ledPin, pwmValue);
  delay(100);
  analogWrite(ledPin, pwmValue);
}

小结

待完善…

https://blog.csdn.net/m0_55733070/article/details/114333194

通过 esp-now 协议实现 esp 设备之间的信息通讯

参考

https://randomnerdtutorials.com/esp-now-one-to-many-esp8266-nodemcu/

BME280 是一个用于测量温度、湿度和气压的传感器。它具有 I2C 和 SPI 接口，因此可以轻松集成到各种项目中。在本教程中，我们将使用 ESP8266 和 BME280 传感器来创建一个简单的 Web 服务器，该服务器将传感器数据发送到浏览器。

代码示例

我们将使用I2C通信与BME280传感器模块。为此，将传感器连接到默认的ESP8266 SCL (GPIO 5) 和SDA (GPIO 4) 引脚，如下面的示意图所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

/*********
  Rui Santos
  Complete instructions at https://RandomNerdTutorials.com/esp8266-nodemcu-websocket-server-sensor/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include "LittleFS.h"
#include <Arduino_JSON.h>
#include <Adafruit_BME280.h>
#include <Adafruit_Sensor.h>

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Create AsyncWebServer object on port 80
AsyncWebServer server(80);

// Create a WebSocket object
AsyncWebSocket ws("/ws");

// Json Variable to Hold Sensor Readings
JSONVar readings;

// Timer variables
unsigned long lastTime = 0;  
unsigned long timerDelay = 30000;

// Create a sensor object
Adafruit_BME280 bme;         // BME280 connect to ESP32 I2C (GPIO 21 = SDA, GPIO 22 = SCL)

// Init BME280
void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

// Get Sensor Readings and return JSON object
String getSensorReadings(){
  readings["temperature"] = String(bme.readTemperature());
  readings["humidity"] =  String(bme.readHumidity());
  readings["pressure"] = String(bme.readPressure()/100.0F);
  String jsonString = JSON.stringify(readings);
  return jsonString;
}

// Initialize LittleFS
void initFS() {
  if (!LittleFS.begin()) {
    Serial.println("An error has occurred while mounting LittleFS");
  }
  else{
   Serial.println("LittleFS mounted successfully");
  }
}

// Initialize WiFi
void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
}

void notifyClients(String sensorReadings) {
  ws.textAll(sensorReadings);
}

void handleWebSocketMessage(void *arg, uint8_t *data, size_t len) {
  AwsFrameInfo *info = (AwsFrameInfo*)arg;
  if (info->final && info->index == 0 && info->len == len && info->opcode == WS_TEXT) {
    //data[len] = 0;
    //String message = (char*)data;
    // Check if the message is "getReadings"
    //if (strcmp((char*)data, "getReadings") == 0) {
      //if it is, send current sensor readings
      String sensorReadings = getSensorReadings();
      Serial.print(sensorReadings);
      notifyClients(sensorReadings);
    //}
  }
}

void onEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) {
  switch (type) {
    case WS_EVT_CONNECT:
      Serial.printf("WebSocket client #%u connected from %s\n", client->id(), client->remoteIP().toString().c_str());
      break;
    case WS_EVT_DISCONNECT:
      Serial.printf("WebSocket client #%u disconnected\n", client->id());
      break;
    case WS_EVT_DATA:
      handleWebSocketMessage(arg, data, len);
      break;
    case WS_EVT_PONG:
    case WS_EVT_ERROR:
      break;
  }
}

void initWebSocket() {
  ws.onEvent(onEvent);
  server.addHandler(&ws);
}

void setup() {
  Serial.begin(115200);
  initBME();
  initWiFi();
  initFS();
  initWebSocket();

  // Web Server Root URL
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
    request->send(LittleFS, "/index.html", "text/html");
  });

  server.serveStatic("/", LittleFS, "/");

  // Start server
  server.begin();
}

void loop() {
  if ((millis() - lastTime) > timerDelay) {
    String sensorReadings = getSensorReadings();
    Serial.print(sensorReadings);
    notifyClients(sensorReadings);

  lastTime = millis();

  }

  ws.cleanupClients();
}

参考

https://randomnerdtutorials.com/esp8266-nodemcu-websocket-server-sensor

引脚连接

pin 引脚连接开发板的 gpio 接口即可：

TFT_eSPI 介绍

API 大全

//以下大多 API 对 Sprite 类也通用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

//初始化
tft.init(); 
//填充全屏幕
tft.fillScreen(uint32_t color); 
//屏幕旋转,参数为：0, 1, 2, 3,分别代表 0°、90°、180°、270°
tft.setRotation(uint8_t r);     
//设置光标位置，font是可选参数
tft.setCursor(int16_t x, int16_t y, uint8_t font);   
//设置字体颜色
tft.setTextColor(uint16_t color); 
//设置文本颜色和背景色
tft.setTextColor(uint16_t fgcolor, uint16_t bgcolor);
//设置字体大小,文本大小范围为 1~7 的整数,特别注意: 字库7是仿7段数码屏的样式
tft.setTextSize(uint8_t size);
//加载字体
display.loadFont(Final_Frontier_28);    
     //括号中为示例，大小为28像素的平滑字体。
     //使用平滑字体时最好用setTextColor同时设置好字体和背景颜色，否则可能会不平滑。
//卸载当前字体
display.unloadFont();
//打印
tft.print("Hello World!");
tft.println("Hello World!");

//绘制字符串
 //居左
 tft.drawString(String, int32_t x, int32_t y, uint8_t font);//font是可选参数
 //居中
 tft.drawCentreString(String, int32_t x, int32_t y, uint8_t font);//font是可选参数
 //居右
 tft.drawRightString(String, int32_t x, int32_t y, uint8_t font);//font是可选参数
//画点
tft.drawPixel(int32_t x, int32_t y, uint32_t color);
//画线
tft.drawLine(int32_t xs, int32_t ys, int32_t xe, int32_t ye, uint32_t color);
//画横线
tft.drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color);
//画竖线
tft.drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color);
//画圆
//空心圆
tft.drawCircle(int32_t x, int32_t y, int32_t r, uint32_t color);
//实心圆
tft.fillCircle(int32_t x, int32_t y, int32_t r, uint32_t color);
//空心椭圆
tft.drawEllipse(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
//实心椭圆
tft.fillEllipse(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
//画矩形
//空心矩形
tft.drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
//实心矩形
tft.fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
//空心圆角矩形
tft.drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_t color);
//实心圆角矩形
tft.drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_t color);
//画三角形
//空心三角形
tft.drawTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, uint32_t color);
//实心三角形
tft.drawTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, uint32_t color);
//显示图片
tft.pushImage(int32_t x, int32_t y, int32_t w, int32_t h, data);

代码示例

mai.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <Arduino.h>
// New background colour
#define TFT_BROWN 0x38E0

// Pause in milliseconds between screens, change to 0 to time font rendering
#define WAIT 1000

#include <TFT_eSPI.h> // Graphics and font library for ILI9341 driver chip
#include <SPI.h>
#include <Wire.h>
#include <User_Setup.h>

TFT_eSPI tft = TFT_eSPI();  // Invoke library, pins defined in User_Setup.h

unsigned long targetTime = 0; // Used for testing draw times

void setup(void) {
  tft.init();
  tft.setRotation(3);
}

void loop() {
  targetTime = millis();

  // First we test them with a background colour set
  tft.setTextSize(1);
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_GREEN, TFT_BLACK);

  tft.drawString(" !\"#$%&'()*+,-./0123456", 0, 0, 2);
  tft.drawString("789:;<=>?@ABCDEFGHIJKL", 0, 16, 2);
  tft.drawString("MNOPQRSTUVWXYZ[\\]^_`", 0, 32, 2);
  tft.drawString("abcdefghijklmnopqrstuvw", 0, 48, 2);
  int xpos = 0;
  xpos += tft.drawString("xyz{|}~", 0, 64, 2);
  tft.drawChar(127, xpos, 64, 2);
  delay(WAIT);
}

userSetup.h

主要更改以下几个地方

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

........
// Only define one driver, the other ones must be commented out
// #define ILI9341_DRIVER       // Generic driver for common displays
//#define ILI9341_2_DRIVER     // Alternative ILI9341 driver, see https://github.com/Bodmer/TFT_eSPI/issues/1172
#define ST7735_DRIVER      // Define additional parameters below for this display
//#define ILI9163_DRIVER     // Define additional parameters below for this display
//#define S6D02A1_DRIVER
//#define RPI_ILI9486_DRIVER // 20MHz maximum SPI
//#define HX8357D_DRIVER
//#define ILI9481_DRIVER
//#define ILI9486_DRIVER
//#define ILI9488_DRIVER     // WARNING: Do not connect ILI9488 display SDO to MISO if other devices share the SPI bus (TFT SDO does NOT tristate when CS is high)
//#define ST7789_DRIVER      // Full configuration option, define additional parameters below for this display
//#define ST7789_2_DRIVER    // Minimal configuration option, define additional parameters below for this display
//#define R61581_DRIVER
//#define RM68140_DRIVER
//#define ST7796_DRIVER
//#define SSD1351_DRIVER
//#define SSD1963_480_DRIVER
//#define SSD1963_800_DRIVER
//#define SSD1963_800ALT_DRIVER
//#define ILI9225_DRIVER
//#define GC9A01_DRIVER

// Some displays support SPI reads via the MISO pin, other displays have a single
// bi-directional SDA pin and the library will try to read this via the MOSI line.
// To use the SDA line for reading data from the TFT uncomment the following line:

// #define TFT_SDA_READ      // This option is for ESP32 ONLY, tested with ST7789 and GC9A01 display only

// For ST7735, ST7789 and ILI9341 ONLY, define the colour order IF the blue and red are swapped on your display
// Try ONE option at a time to find the correct colour order for your display

 #define TFT_RGB_ORDER TFT_RGB  // Colour order Red-Green-Blue
//  #define TFT_RGB_ORDER TFT_BGR  // Colour order Blue-Green-Red

// For ST7789, ST7735, ILI9163 and GC9A01 ONLY, define the pixel width and height in portrait orientation
// #define TFT_WIDTH  80
#define TFT_WIDTH  128
// #define TFT_WIDTH  172 // ST7789 172 x 320
// #define TFT_WIDTH  170 // ST7789 170 x 320
// #define TFT_WIDTH  240 // ST7789 240 x 240 and 240 x 320
#define TFT_HEIGHT 160
// #define TFT_HEIGHT 128
// #define TFT_HEIGHT 240 // ST7789 240 x 240
// #define TFT_HEIGHT 320 // ST7789 240 x 320
// #define TFT_HEIGHT 240 // GC9A01 240 x 240
.......

小结

待完善…

参考

http://www.lcdwiki.com/zh/0.96inch_IPS_Module

使用tft屏幕全踩坑指南

你是不是厌倦了在Arduino项目中反复使用字符LCD显示器？事实上，它们已经成为过去。进入梦幻般的OLED（有机发光二极管）显示屏！它们非常轻，几乎像纸一样薄，理论上是灵活的，可以产生更明亮、更清晰的图像。

OLED显示器有各种尺寸（例如128×64、128×32）和颜色（例如白色，蓝色和双色OLED）。一些OLED显示器具有I2C接口，而另一些则具有SPI接口。

但是，他们都有的一件事是，他们的核心是强大的单芯片CMOS OLED驱动器控制器-SSD1306，它可以处理所有RAM缓冲，因此您的Arduino几乎不需要工作。

在本教程中，我们将同时使用I2C和SPI 0.96英寸128×64 OLED显示器。不用担心您的模块是不同的尺寸或颜色；此页面上的信息仍然有用。

SPI 和 I2C 怎么选？

SPI通常比I2C快，但需要更多的I/O引脚。另一方面，I2C仅需要两个引脚，并且可以与其他I2C外围设备共享。因为这是引脚和速度之间的权衡，所以选择完全取决于场景需要。

引脚连接

pin 引脚连接开发板的 gpio 接口即可：

代码示例

使用 Adafruit_SSD1306

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#include <Arduino.h>
#include <Adafruit_SSD1306.h>

int SDA_PIN = 8;
int SCL_PIN = 9;

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  Serial.begin(9600);
  Wire.begin(SDA_PIN, SCL_PIN);
 // Clear the buffer.
  display.clearDisplay();

  // Display Text
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,28);
  display.println("Hello world!");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Display Inverted Text
  display.setTextColor(BLACK, WHITE); // 'inverted' text
  display.setCursor(0,28);
  display.println("Hello world!");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Changing Font Size
  display.setTextColor(WHITE);
  display.setCursor(0,24);
  display.setTextSize(2);
  display.println("Hello!");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Display Numbers
  display.setTextSize(1);
  display.setCursor(0,28);
  display.println(123456789);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Specifying Base For Numbers
  display.setCursor(0,28);
  display.print("0x"); display.print(0xFF, HEX); 
  display.print("(HEX) = ");
  display.print(0xFF, DEC);
  display.println("(DEC)"); 
  display.display();
  delay(2000);
  display.clearDisplay();

  // Display ASCII Characters
  display.setCursor(0,24);
  display.setTextSize(2);
  display.write(3);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Scroll full screen
  display.setCursor(0,0);
  display.setTextSize(1);
  display.println("Full");
  display.println("screen");
  display.println("scrolling!");
  display.display();
  display.startscrollright(0x00, 0x07);
  delay(2000);
  display.stopscroll();
  delay(1000);
  display.startscrollleft(0x00, 0x07);
  delay(2000);
  display.stopscroll();
  delay(1000);    
  display.startscrolldiagright(0x00, 0x07);
  delay(2000);
  display.startscrolldiagleft(0x00, 0x07);
  delay(2000);
  display.stopscroll();
  display.clearDisplay();

  // Scroll part of the screen
  display.setCursor(0,0);
  display.setTextSize(1);
  display.println("Scroll");
  display.println("some part");
  display.println("of the screen.");
  display.display();
  display.startscrollright(0x00, 0x00);
}


void loop() {
}

使用U8g2

如果是最小系统板，建议不要用这个库,性能要求会比较高

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <Arduino.h>
#include <U8g2lib.h>
 
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

// 这里更改为开发板对应的引脚，当前示例以 esp32-c3 为例
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* reset=*/ U8X8_PIN_NONE);  
// esp8266
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
 
void setup(void) {
  u8g2.begin();
//  u8x8.setFlipMode(1);   // set number from 1 to 3, the screen word will rotary 180
}
 
void loop(void) {
  u8g2.clearBuffer();                   // clear the internal memory
  u8g2.setFont(u8g2_font_ncenB08_tr);   // choose a suitable font
  u8g2.drawStr(0,15,"Hello World!");    // write something to the internal memory
  u8g2.sendBuffer();                    // transfer internal memory to the display
//  delay(1000);  
}

以下是 ESP32-c3-supermini 上的表现

关于Arduino的好处之一是，它具有相当多的I/O口。您可以连接一些按钮，传感器，伺服器等，但是随着设备的增加，有可能很快就会用完引脚。

解决方案之一就是本文介绍的–移位寄存器，该寄存器使我们可以在Arduino（或任何微控制器）中添加更多的I/O引脚。到目前为止，最广泛使用的移位寄存器是74HC595，也称为“595”。

74HC595只用仅三个输入引脚控制八个不同的输出引脚。如果需要超过8个I/O引脚，则可以根据需要尽可能多的链来生成大量的I/O引脚。

工作原理

74HC595具有两个8位寄存器（可以将其视为“内存容器”）。第一个称为移位寄存器，第二个称为存储/闩锁寄存器。

每次74HC595收到时钟脉冲时，都会发生两件事：

• 移位寄存器中包含的位通过一个位置向左移动。位0的值将其推入位1，而位1的值则将其推入位2，依此类推。
• 移位寄存器中的位0接受数据引脚上的当前值。在时钟脉冲的上升边缘上，如果数据引脚高，则将1推入移位寄存器，否则为0。

只要74HC595被计时，这个过程就会继续。

启用闩锁引脚后，将移位寄存器的内容复制到存储/闩锁寄存器。存储寄存器的每个位均链接到IC的输出引脚之一QA-QH。结果，每当存储寄存器中的值更改时，输出就会更改。

下面的动画将帮助你更好地理解它。

Sipo vs Piso Shift寄存器

有两种类型的移位寄存器：SIPO（并行序列）和PISO（并行在串行中）。

SIPO可用于控制大量输出，例如LED。尽管PISO可用于收集大量输入，例如按钮，类似于上面讨论的原始 arduino 控制器。

最受欢迎的SIPO芯片是74HC595，最受欢迎的PISO芯片是74HC165。

引脚连接

SER（串行输入）引脚用于一次向移位寄存器发送一位数据。

SRCLK（移位寄存器时钟）是移位寄存器的时钟，由正沿触发。这意味着这些比特在时钟的上升沿被推入。

RCLK（寄存器时钟/锁存）是一个非常重要的引脚。当该引脚被拉高时，移位寄存器的内容被复制到存储/锁存寄存器中，最终出现在输出端。因此，锁存引脚可以看作是我们在输出端看到结果之前的最后一步。

SRCLR（移位寄存器清除）引脚允许我们重置整个移位寄存器，将所有位设置为零。因为这是一个活动低引脚，我们必须将SRCLR引脚拉低以执行重置。

OE（输出启用）也是一个低电平引脚：当拉高时，输出引脚被禁用（设置为高阻抗状态）。当它被拉低时，输出引脚正常工作。

QA–QH（输出启用）是输出引脚。

QH: 引脚输出移位寄存器的第7位。这允许您对74HC595进行链连接。如果将此引脚连接到另一个74HC595的SER引脚，并向两个IC提供相同的时钟信号，它们的行为就像一个具有16个输出的单个IC。当然，使用这种技术，您可以菊花链连接任意数量的IC。

将引脚16（VCC）和10（SRCLR）连接到Arduino的5V输出，引脚8（GND）和13（OE）连接到地。这应该使IC保持在正常工作模式。

接下来，连接将用于控制移位寄存器的三个引脚。将移位寄存器的引脚11（SRCLK）、引脚12（RCLK）和引脚14（SER）分别连接到Arduino的引脚6、5和4。

剩下的就是将LED连接到输出引脚。将每个LED的阴极（短引脚）连接到公共接地，将每个LED（长引脚）的阳极连接到其各自的移位寄存器输出引脚。

不要忘记串联一个220Ω的电阻器，以保护LED免受过载。

连接LED时，确保QA连接到第一个LED，QH连接到最后一个LED；否则，LED将不会以正确的顺序亮起！

下图显示了如何将所有内容连接起来。

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <Arduino.h>

int latchPin = A4;      // Latch pin of 74HC595 is connected to Digital pin 5
int clockPin = A3;      // Clock pin of 74HC595 is connected to Digital pin 6
int dataPin = A2;       // Data pin of 74HC595 is connected to Digital pin 4

byte leds = 0;         // Variable to hold the pattern of which LEDs are currently turned on or off

void setup() 
{
  // Set all the pins of 74HC595 as OUTPUT
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
}

void loop() 
{
  leds = 0;        // Initially turns all the LEDs off, by giving the variable 'leds' the value 0
  updateShiftRegister();
  delay(500);
  for (int i = 0; i < 8; i++)        // Turn all the LEDs ON one by one.
  {
    bitSet(leds, i);                // Set the bit that controls that LED in the variable 'leds'
    updateShiftRegister();
    delay(500);
  }
}

void updateShiftRegister()
{
   digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, LSBFIRST, leds);
   digitalWrite(latchPin, HIGH);
}

使用PWM控制亮度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <Arduino.h>
int latchPin = A5;           // Latch pin of 74HC595 is connected to Digital pin 5
int clockPin = 6;           // Clock pin of 74HC595 is connected to Digital pin 6
int dataPin = A4;            // Data pin of 74HC595 is connected to Digital pin 4
int outputEnablePin = A3;    // OE pin of 74HC595 is connected to PWM pin 3

byte leds = 0;              // Variable to hold the pattern of which LEDs are currently turned on or off

void setup() 
{
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
  pinMode(outputEnablePin, OUTPUT); 
}

void loop() 
{
  setBrightness(255);
  leds = 0;                // Initially turns all the LEDs off, by giving the variable 'leds' the value 0
  updateShiftRegister();
  delay(500);
  for (int i = 0; i < 8; i++)        // Turn all the LEDs ON one by one.
  {
    bitSet(leds, i);                // Set the bit that controls that LED in the variable 'leds'
    updateShiftRegister();
    delay(500);
  }
  for (byte b = 255; b > 0; b--)        // Gradually fade all the LEDs back to off
  {
    setBrightness(b);
    delay(50);
  }
}

void updateShiftRegister()
{
   digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, LSBFIRST, leds);
   digitalWrite(latchPin, HIGH);
}

void setBrightness(byte brightness) // 0 to 255
{
  analogWrite(outputEnablePin, 255-brightness);
}

小结

74HC595是一个8位串行输入/并行输出移位寄存器。它允许您将数据从Arduino发送到8个或更多的输出引脚，而不需要使用Arduino的每个输出引脚。

我们被步进电动机所包围，甚至没有意识到，因为它们都用于许多日常用品中，包括窗户百叶窗，3D打印机，DVD播放器，安全摄像头和CNC机器。我们离步进电动机比您想象的要近得多。

步进电动机落在传统的直流电动机和伺服电动机之间。它们可以像直流电动机一样连续旋转，并精确地定位（以离散步骤）等伺服电动机。

如果您刚开始使用步进电动机，那么28ByJ-48是一个不错的选择。它们通常配备基于ULN2003的驾驶员板，使其非常易于使用。

工作原理

每个高脉冲发送都会使线圈通电，吸引最接近齿轮的牙齿，并以称为台阶的精确和固定角度增量旋转电动机。

步进电动机在360度旋转中具有的步骤数实际上是齿轮上的牙齿数量。

这些线圈的脉冲方式确定电动机的运行方式：

• 脉冲的序列确定电动机的旋转方向。

• 脉冲的频率决定了电动机的速度。

• 脉冲的数量确定电动机将转向多远。

通过以正确的序列为线圈通电，电动机旋转。

驱动连接

由于28ByJ-48步进电动机会消耗大量功率，因此无法直接由Arduino等微控制器控制。为了控制电动机，需要诸如ULN2003之类的驱动器IC；因此，该电动机通常带有基于ULN2003的驾驶员板。由于我用的是 L293D，本文会从 L293D 的使用来展开驱动说明。

引脚连接

28ByJ-48单极步进电动机的额定值为5V，每革命提供48个步骤。因此，将外部5V电源连接到EXT_PWR终端。

不要忘记删除PWR跳线。不要忘记删除PWR跳线。不要忘记删除PWR跳线。

最后，将电动机连接到步进电机端子M1-M2（端口＃1）或M3-M4（端口＃2）。我们将其连接到M3-M4。

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <Arduino.h>
#include <AFMotor.h>

//每个输出旋转的步骤数
//根据电机规格进行更改
const int stepsPerRevolution = 48;

// connect motor to port #2 (M3 and M4)
AF_Stepper motor(stepsPerRevolution, 2);

void setup() {
  Serial.begin(9600);
  Serial.println("Stepper test!");

  motor.setSpeed(10);  // 10 rpm   
}

void loop() {
  Serial.println("Single coil steps");
  motor.step(100, FORWARD, SINGLE); 
  motor.step(100, BACKWARD, SINGLE); 

  Serial.println("Double coil steps");
  motor.step(100, FORWARD, DOUBLE); 
  motor.step(100, BACKWARD, DOUBLE);

  Serial.println("Interleave coil steps");
  motor.step(100, FORWARD, INTERLEAVE); 
  motor.step(100, BACKWARD, INTERLEAVE); 

  Serial.println("Micrsostep steps");
  motor.step(100, FORWARD, MICROSTEP); 
  motor.step(100, BACKWARD, MICROSTEP); 
}

在代码的设置和循环部分中，我们只需调用下面列出的两个功能即可控制电动机的速度和方向。

• setSpeed（rpm）设置了电动机的速度，其中rpm是您希望步进的每分钟旋转数量。
• 每次您希望电动机移动时，step(#steps, direction, steptype)函数都会调用。#steps 是您要采取的步骤的数量。direction是向前或向后，stepstyle可以是以下任何一个：
  • SINGLE - 一次线圈一次通电。
  • DOUBLE - 一次启动两个线圈以进行更多的扭矩。
  • INTERLEAVE - 在单个和双重之间进行替代，以在两者之间创建半步。这可能会导致操作更顺畅，但是由于额外的半步，速度降低了一半。
  • MICROSTEP - 在每个整个步骤之间，相邻的线圈都会上下倾斜以创建许多微步骤。这会产生更好的分辨率和更平滑的旋转，但以扭矩为代价。

小结

步进电机是一种非常常见的电机，广泛应用于各种场合。通过本文的学习，我们可以了解到步进电机的原理、驱动连接以及如何使用Arduino控制步进电机。希望本文对您有所帮助！

有许多电机可供选择，但为工作选择合适的电机很重要。如果您的项目需要精确定位，伺服电机通常是最佳选择。指示他们指向哪里，他们会为你做的。就这么简单！

它们在各种机器人项目中很有用，例如转向RC型号的前轮或在机器人车上旋转传感器。

工作原理

伺服器是使您可以精确控制身体运动的电动机，因为它们通常移至位置而不是不断旋转。它们很容易连接和控制，因为电动机驱动器是直接构建的。

伺服器包含通过齿轮连接到输出轴的小型直流电动机。输出轴驱动伺服喇叭，还与电位计相连。

电位计提供了控制单元中误差放大器的位置反馈，该放大器将电动机的当前位置与目标位置进行了比较。

为了响应错误，控制单元调整了电动机的当前位置，以使其与所需的位置匹配。

在控制工程中，这种机制被称为伺服力机制，或者简称为伺服。这是一个闭环控制系统，它使用负反馈来调整电动机的速度和方向以达到所需的结果。

注意: 脉冲与位置之间的确切关系没有标准，因此您可能需要调整草图以调整伺服器的范围。而且，脉搏持续时间在品牌之间可能有所不同。例如，它可能为180度的2.5ms，0度为0.5ms。

引脚连接

pin 引脚连接开发板的 gpio 接口即可：

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <Arduino.h>
#include <Servo.h>

int servoPin = A2;
Servo servo;
int angle = 0;

void setup() {
    servo.attach(servoPin);
}

void loop() {
    for(angle = 0; angle < 180; angle++) {
        servo.write(angle);
        delay(15);
    }
    
    for(angle = 180; angle > 0; angle--) {
        servo.write(angle);
        delay(15);
    }
}

用电位器控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <Arduino.h>
#include <Servo.h>

int potPin = A0;
int servoPin = A2;
Servo servo;

void setup() {
    servo.attach(servoPin);
}

void loop() {
    int reading = analogRead(potPin);
    int angle = map(reading, 0, 1023, 0, 180);  // 映射角度
    servo.write(angle);
}

小结

舵机是一种非常实用的电机，可以用于各种需要精确控制位置的应用。通过简单的代码和连接，您就可以控制舵机旋转到指定的角度。如果您需要更复杂的控制，例如连续旋转或精确控制速度，您可能需要使用更高级的伺服驱动器。

借助基于RFID的步行自动结帐解决方案，可以用来实现快速购物车结账。不需要再等待某人一一敲响购物车中的每个物品；现在，利用附加在项目上的RFID标签，将几乎立即检测到购物车中的每个项目。

对于大多数基于RFID的Arduino项目，RC522 RFID读取器/写入模块是一个不错的选择。它是低功率，低成本，非常坚固，易于接入，并且在业余爱好者中非常受欢迎。

工作原理

RFID或射频标识系统由两个主要组件组成，标签添加到要识别的客户端和读取标签的服务端。

读取器由射频模块和产生高频电磁场的天线组成。而标签通常是一个被动设备（没有电池）。它由一个存储和处理信息的微芯片以及用于接收和传输信号的天线。

引脚连接

Tips: 用例使用的是 esp32-c3-supermini，对应的引脚是 A4、A5，如果在 platformIO 上开发的话，直接输入引脚名称会提示当前的引脚对应数字号。

代码示例

写入端

这个是给卡片写入数据的案例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#include <Arduino.h>
#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN A7
#define RST_PIN A0

MFRC522 mfrc522(SS_PIN, RST_PIN); // instatiate a MFRC522 reader object.
MFRC522::MIFARE_Key key;// create a MIFARE_Key struct named 'key', which will hold the card information

// this is the block number we will write into and then read.
int block = 2;

byte blockcontent[16] = {"Last-Minute-Engg"}; // an array with 16 bytes to be written into one of the 64 card blocks is defined
// byte blockcontent[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};  //all zeros. This can be used to delete a block.

// This array is used for reading out a block.
byte readbackblock[18];

void setup()
{
Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin();// Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)
Serial.println("Scan a MIFARE Classic card");

// Prepare the security key for the read and write functions.
for (byte i = 0; i < 6; i++)
{
key.keyByte[i] = 0xFF; // keyByte is defined in the "MIFARE_Key" 'struct' definition in the .h file of the library
}
}

void loop()
{
// Look for new cards
if (!mfrc522.PICC_IsNewCardPresent())
{
return;
}

// Select one of the cards
if (!mfrc522.PICC_ReadCardSerial())
{
return;
}
Serial.println("card selected");

// the blockcontent array is written into the card block
writeBlock(block, blockcontent);

// read the block back
readBlock(block, readbackblock);
// uncomment below line if you want to see the entire 1k memory with the block written into it.
// mfrc522.PICC_DumpToSerial(&(mfrc522.uid));

// print the block contents
Serial.print("read block: ");
for (int j = 0; j < 16; j++)
{
Serial.write(readbackblock[j]);
}
Serial.println("");
}

// Write specific block
int writeBlock(int blockNumber, byte arrayAddress[])
{
// this makes sure that we only write into data blocks. Every 4th block is a trailer block for the access/security info.
int largestModulo4Number = blockNumber / 4 * 4;
int trailerBlock = largestModulo4Number + 3; // determine trailer block for the sector
if (blockNumber > 2 && (blockNumber + 1) % 4 == 0)
{
Serial.print(blockNumber);
Serial.println(" is a trailer block:");
return 2;
}
Serial.print(blockNumber);
Serial.println(" is a data block:");

// authentication of the desired block for access
byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
if (status != MFRC522::STATUS_OK)
{
Serial.print("PCD_Authenticate() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 3; // return "3" as error message
}

// writing the block
status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16);
// status = mfrc522.MIFARE_Write(9, value1Block, 16);
if (status != MFRC522::STATUS_OK)
{
Serial.print("MIFARE_Write() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 4; // return "4" as error message
}
Serial.println("block was written");
}

// Read specific block
int readBlock(int blockNumber, byte arrayAddress[])
{
int largestModulo4Number = blockNumber / 4 * 4;
int trailerBlock = largestModulo4Number + 3; // determine trailer block for the sector

// authentication of the desired block for access
byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));

if (status != MFRC522::STATUS_OK)
{
Serial.print("PCD_Authenticate() failed (read): ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 3; // return "3" as error message
}

// reading a block
byte buffersize = 18;// we need to define a variable with the read buffer size, since the MIFARE_Read method below needs a pointer to the variable that contains the size...
status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize); //&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number
if (status != MFRC522::STATUS_OK)
{
Serial.print("MIFARE_read() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 4; // return "4" as error message
}
Serial.println("block was read");
}

读取端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN 9
#define SS_PIN 10

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance

void setup()
{
Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin();// Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)
Serial.println("Scan a MIFARE Classic card");
}

void loop() {
// Look for new cards
if (!mfrc522.PICC_IsNewCardPresent())
{
return;
}

// Select one of the cards
if (!mfrc522.PICC_ReadCardSerial())
{
return;
}
Serial.println("card selected");

// print UID
Serial.print("UID: "); for (byte i = 0; i < mfrc522.uid.size; i++) {
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
}
Serial.println();

// Halt PICC
mfrc522.PICC_HaltA();
// Stop encryption on PCD
mfrc522.PCD_StopCrypto1();
}

小结

RC522 是一款非接触式IC卡读写器，可以用于读取和写入MIFARE Classic卡。在本文中，我们介绍了如何使用Arduino和RC522来读取和写入MIFARE Classic卡。我们首先介绍了如何初始化RC522，然后介绍了如何读取和写入MIFARE Classic卡。最后，我们提供了一个完整的示例代码，演示了如何使用Arduino和RC522来读取和写入MIFARE Classic卡。

参考

dev 的艺术空间

RC522

如果你曾经有一个热水器爆炸或试图建造潜水电子产品，那么你就会知道检测到水的重要性。

这款水位传感器它可以用来测量水位，监测污水坑，检测降雨并检测泄漏。

工作原理

引脚连接

pin 引脚连接开发板的 gpio 接口即可：

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <Arduino.h>

#define sensorPower 3
#define sensorPin A2

int val = 0;

void setup()
{
pinMode(sensorPower, OUTPUT);
digitalWrite(sensorPower, LOW);
Serial.begin(9600);
}

void loop()
{
int level = readSensor();

Serial.print("Water level: ");
Serial.println(level);

delay(1000);
}

int readSensor()
{
digitalWrite(sensorPower, HIGH); // Turn the sensor ON
delay(10); // wait 10 milliseconds
val = analogRead(sensorPin); // Read the analog value form sensor
digitalWrite(sensorPower, LOW); // Turn the sensor OFF
return val; // send current reading
}

小结

水位传感器可以用来测量水位，监测污水坑，检测降雨并检测泄漏。

当听到 “智能花园” 一词时，想到的第一件事是监视土壤水分水平并自动向植物提供必要量的水的系统。

使用该系统，只有在需要时才能浇水，避免过度或不足的植物。如果您想构建这样的系统，毫无疑问，您将需要土壤水分传感器。

工作原理

带有两个暴露导体的叉形探头充当可变电阻器（类似于电位计），其电阻随土壤含水量而变化。

电阻大小随土壤水分而变化：

土壤中的水越多，电导率越好，电阻越高。

土壤中的水越少，电导率就越低，因此电阻越高。

然后传感器根据电阻产生输出电压，通过测量我们可以确定土壤水分水平。

引脚连接

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <Arduino.h>

#define soilWet 500 // Define max value we consider soil 'wet'
#define soilDry 750 // Define min value we consider soil 'dry'

#define sensorPower A3
#define sensorPin A2

void setup()
{
pinMode(sensorPower, OUTPUT);
digitalWrite(sensorPower, LOW);
Serial.begin(9600);
}

void loop()
{
int moisture = readSensor();
Serial.print("Analog Output: ");
Serial.println(moisture);

if (moisture < soilWet)
{
Serial.println("Status: Soil is too wet");
}
else if (moisture >= soilWet && moisture < soilDry)
{
Serial.println("Status: Soil moisture is perfect");
}
else
{
Serial.println("Status: Soil is too dry - time to water!");
}

delay(1000); // Take a reading every second for testing
Serial.println();
}

int readSensor()
{
digitalWrite(sensorPower, HIGH); // Turn the sensor ON
delay(10); // Allow power to settle
int val = analogRead(sensorPin); // Read the analog value form sensor
digitalWrite(sensorPower, LOW); // Turn the sensor OFF
return val; // Return analog moisture value
}

拓展

可以搭配显示屏和蜂鸣器，做一个智能浇花系统系统。当然，如果接入钉钉通知就更好了。

小结

土壤湿度传感器是智能灌溉系统的重要组成部分，它可以帮助我们更好地管理植物的生长环境，提高农作物的产量和质量。通过使用土壤湿度传感器，我们可以避免过度或不足的浇水，从而减少水资源浪费和植物损伤。同时，土壤湿度传感器还可以与其他传感器和设备进行集成，实现更复杂的智能灌溉系统。

原理

在麦克风内部，有一个薄的隔膜和背板。它们在一起形成了电容器。

当声音经过麦克风时，声音产生的声波撞到了隔膜，使其振动。

随着隔膜振动的振动，它离背板更近或远。这种运动改变了它们之间的电容。电容的这种变化会在板上产生电压，我们可以测量以确定声音的幅度。

引脚连接

pin 引脚连接开发板的 gpio 接口即可：

代码示例

小结

参考

https://arduinogetstarted.com/tutorials/arduino-button-debounce

https://lastminuteengineers.com/max4466-arduino-tutorial/

这是一个精心设计的模块，具有灵活的电源电压和可调节的增益，使其适用于广泛的音频应用。该模块特别适用于实时语音更换器，音频录制/采样以及使用快速傅立叶变换（FFT）算法的音频反应性项目。

原理

在麦克风内部，有一个薄的隔膜和背板。它们在一起形成了电容器。

当声音经过麦克风时，声音产生的声波撞到了隔膜，使其振动。

随着隔膜振动的振动，它离背板更近或远。这种运动改变了它们之间的电容。电容的这种变化会在板上产生电压，我们可以测量以确定声音的幅度。

引脚连接

pin 引脚连接开发板的 gpio 接口即可：

代码示例

下面介绍一个简单的驱动示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <Arduino.h>

const int sampleWindow = 50;  // Sample window width in mS (50 mS = 20Hz)
int const AMP_PIN = A2;       // Preamp output pin connected to A0
unsigned int sample;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  unsigned long startMillis = millis(); // Start of sample window
  unsigned int peakToPeak = 0;   // peak-to-peak level

  unsigned int signalMax = 0;
  unsigned int signalMin = 1024;

  // collect data for 50 mS and then plot data
  while (millis() - startMillis < sampleWindow)
  {
    sample = analogRead(AMP_PIN);
    if (sample < 1024)  // toss out spurious readings
    {
      if (sample > signalMax)
      {
        signalMax = sample;  // save just the max levels
      }
      else if (sample < signalMin)
      {
        signalMin = sample;  // save just the min levels
      }
    }
  }
  peakToPeak = signalMax - signalMin;  // max - min = peak-peak amplitude
  Serial.println(peakToPeak);
  //double volts = (peakToPeak * 5.0) / 1024;  // convert to volts
  //Serial.println(volts);
}

拓展

这个模块可以通过和 LED 连接做一个类似光随声动的项目。

小结

MX4466 是一个简单易用的麦克风前置放大器模块，适用于各种音频应用。通过简单的引脚连接和代码示例，可以轻松实现音频信号的采集和处理。

参考

https://arduinogetstarted.com/tutorials/arduino-button-debounce

https://lastminuteengineers.com/max4466-arduino-tutorial/

游戏

代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <Arduino.h>
#include <ezAnalogKeypad.h>

ezAnalogKeypad keypad(A2);  // create ezAnalogKeypad object that attach to pin A0

void setup() {
  Serial.begin(9600);

  // MUST READ: You MUST run the calibration example, press key one-by-one to get the analog values
  // The below values is just an example, your keypad's value may be different
  keypad.setNoPressValue(0);  // analog value when no key is pressed
  keypad.registerKey('1', 100); // analog value when the key '1' is pressed
  keypad.registerKey('2', 150); // analog value when the key '2' is pressed
  keypad.registerKey('3', 200); // analog value when the key '3' is pressed
  keypad.registerKey('4', 250); // analog value when the key '4' is pressed
  keypad.registerKey('*', 450); // analog value when the key '*' is pressed
  keypad.registerKey('0', 500); // analog value when the key '0' is pressed
  keypad.registerKey('#', 550); // analog value when the key '#' is pressed
  keypad.registerKey('d9', 4095); // analog value when the key '#' is pressed
}

void loop() {
  unsigned char key = keypad.getKey();
  if (key) {
    Serial.println(key);
  }
}