Rancho's Notes

一转四USB转TTL模块

Sat, 01 Mar 2025 08:14:58 +0000

经常会遇到USB转TTL模块不够用的情况，因此这次直接搞一个一转四的USB转TTL模块，这下总够用了吧；

原理图

设计原理图

PCB

PCB图

PCB仿真图(正面)

PCB仿真图(反面)

在线BOM

BOM

实物图

实物图(正面)

实物图(反面)

四个COM口！！！！

LOG分级打印

Sun, 06 Aug 2023 03:46:57 +0000

这个是关于LOG分级打印的配置，并有时间戳，基于STM32H7和gcc；

环境

STM32H743IIT6、STM32CubeMX、GCC、MakeFile

printf映射

usart.c中加入以下代码

#include "stdio.h"
/*# 7- Retarget printf to UART (std library and toolchain dependent) #########*/

#if defined(__GNUC__)
int _write(int fd, char *ptr, int len)
{
    HAL_UART_Transmit(&huart1, (uint8_t *)ptr, len, HAL_MAX_DELAY);
    return len;
}
#elif defined(__ICCARM__)
#include "LowLevelIOInterface.h"
size_t __write(int handle, const unsigned char *buffer, size_t size)
{
    HAL_UART_Transmit(&huart1, (uint8_t *)buffer, size, HAL_MAX_DELAY);
    return size;
}
#elif defined(__CC_ARM)
int fputc(int ch, FILE *f)
{
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
    return ch;
}
#endif

#ifdef __GNUC__
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */

/**
 * @brief  Retargets the C library printf function to the USART.
 * @param  None
 * @retval None
 */
PUTCHAR_PROTOTYPE
{
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY);
    return ch;
}

MakeFile中删除以下配置：

windows11下uboot烧录

Sat, 29 Jul 2023 08:11:50 +0000

windows11下如何烧录uboot镜像呢？当然是用windows下的dd命令了；

首先下载dd.exe，并将其命名为dd.exe，将其加入系统变量；

http://www.chrysocome.net/downloads/ddrelease64.exe

测试如下图所示即安装成功：

然后已有u-boot-sunxi-with-spl.bin，因而插入SD卡，输入以下命令：

dd.exe if=.\u-boot-sunxi-with-spl.bin of=d:\temp.img bs=1024 seek=8

然后使用DiskImager将temp.img镜像烧录进SD卡即可。

感觉之后生成的各种镜像只要组合成一个大的image就可以。

buildroot的OVERRIDE_SRCDIR机制

Wed, 14 Jun 2023 02:58:23 +0000

使用buildroot构建系统的话，如果在output/build中对某个软件包修改的话，一旦使用make clean，就会导致自己做的修改被抹除；为避免这个情况，buildroot是提供了一种机制，也即OVERRIDE_SRCDIR；参考：https://www.cnblogs.com/pwl999/p/15534966.html

Buildroot的一般操作是下载tar包、提取、配置、编译和安装该tar包内的软件。源代码提取保存在临时目录output/build/-目录中，当执行make clean时，该目录会被完全删除，并在下一次make时重新创建。即使将Git或Subversion等版本管理系统作为软件包源代码的输入，Buildroot也会从中创建一个tar包，然后像对待一般tar包一样工作。

这种方式非常适合将Buildroot当做集成工具，编译和集成嵌入式Linux系统的所有组件。但是，如果是在开发系统的某些组件的过程中使用Buildroot，这种方式非常不方便：开发者希望对一个软件包的源代码做少许修改，并能够使用Buildroot快速重建系统。直接修改output/build/-不是合适的解决方案，因为该目录会在make clean时删除。

因此，Buildroot针对该场景提供了一种特殊的机制，即_OVERRIDE_SRCDIR机制。Buildroot读取一个override文档，该文档允许用户告诉Buildroot某些软件包的源代码位置。

覆盖文档(override)的默认位置是$(CONFIG_DIR)/local.mk。由BR2_PACKAGE_OVERRIDE_FILE配置选项定义。$(CONFIG_DIR)是Buildroot .config文档的位置，因此local.mk默认情况下与.config文档放在一起，这意味着：这意味着:

Buildroot目录树内构建时位于Buildroot顶层目录中（当O=不使用时）
Buildroot目录树外构建时位于目录树外目录（当O=使用时）

如果需要不同于这些默认值的位置，可以通过BR2_PACKAGE_OVERRIDE_FILE配置选项指定。

在这个override文档中，Buildroot期望找到以下形式中的行:


_OVERRIDE_SRCDIR = /path/to/pkg1/sources

_OVERRIDE_SRCDIR = /path/to/pkg2/sources

例如:

LINUX_OVERRIDE_SRCDIR = /home/bob/linux/
BUSYBOX_OVERRIDE_SRCDIR = /home/bob/busybox/

当Buildroot发现给定的软件包存在_OVERRIDE_SRCDIR定义时，它将不再尝试下载、提取和修补软件包，它将直接使用指定目录中可用的源代码，并且make clean时不会涉及该目录。这允许将Buildroot指向您自己的目录，该目录可以由Git、Subversion或其他版本控制系统管理。为此，Buildroot将使用rsync将软件包的源代码从_OVERRIDE_SRCDIR指定的位置复制到output/build/-custom/目录。

该机制最好与make -rebuild和make -reconfigure结合使用。make-rebuild all将rsync源代码从_OVERRIDE_SRCDIR到output/build/-custom（只有修改过的文档会被复制），并重新启动这个软件包的构建过程。

在上述Linux软件包的示例中，开发人员可以修改 /home/bob/linux目录下的源代码，然后运行：

make linux-rebuild all

并在几秒钟内在output/images中获得更新后的Linux内核映像。类似地，可以在/home/bob/busybox和后面对BusyBox源代码进行更改:

make busybox-rebuild all

output/images中的根文档系统映像包含更新后的BusyBox。

大型项目一般有成百上千的文档，很多文档对于构建时是不需要的，但是会减慢rsync复制源代码的过程。可选的，可以定义_OVERRIDE_SRCDIR_RSYNC_EXCLUSIONS跳过源代码中的某些文档。例如，当处理webkitgtk软件包时，以下内容将从本地WebKit源代码中排除：

WEBKITGTK_OVERRIDE_SRCDIR = /home/bob/WebKit
WEBKITGTK_OVERRIDE_SRCDIR_RSYNC_EXCLUSIONS = \
        --exclude JSTests --exclude ManualTests --exclude PerformanceTests \
        --exclude WebDriverTests --exclude WebKitBuild --exclude WebKitLibraries \
        --exclude WebKit.xcworkspace --exclude Websites --exclude Examples

默认情况下，Buildroot会跳过VCS信息（例如.git或.svn）的同步。一些软件包在编译过程中会使用VCS信息，例如精确确认提交信息。要取消Buildroot的内置过滤规则，需要重新添加以下目录：

LINUX_OVERRIDE_SRCDIR_RSYNC_EXCLUSIONS = --include .git

全志H3开发

Mon, 12 Jun 2023 02:34:07 +0000

最近买了一块便宜的Linux开发板，是基于全志H3芯片的，想从头到尾跑一下开发流程；

Uboot开发

环境搭建

安装好make、arm-linux-gnueabihf-等工具。

Uboot编译

源码下载：https://ftp.denx.de/pub/u-boot/

wget https://ftp.denx.de/pub/u-boot/u-boot-2020.04.tar.bz2

选择u-boot-2020.04.tar.bz2即可；

使用以下命令进行解压操作：

tar -xvf u-boot-2020.04.tar.bz2

然后进行编译选项配置：

cd u-boot-2020.04/
make -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- orangepi_lite_defconfig

编译：

make -j4 ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- V=1

Uboot烧录

准备一个micro SD卡（大于8GB）；

通过读卡器插入电脑；

安装并打开gparted：

sudo apt install gparted
sudo gparted

按照以下方式修改分区配置：

可能会出现/sdb大小不对的问题，可以先取下读卡器，然后使用sudo rm -rf /dev/sdb即可，然后再次进行分区即可；

使用以下命令进行烧录即可：

sudo dd if=u-boot-sunxi-with-spl.bin of=/dev/sdb bs=1024 seek=8

上电测试

将SD卡插入开发板，给开发板上电，打开调试接口接口看到以下输出：

Linux内核开发

源码下载

git clone --depth 1  --branch orange-pi-5.4  https://ghproxy.com/https://github.com/orangepi-xunlong/linux-orangepi.git
cd linux-orangepi/

编译

make sunxi_defconfig ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
make -j8 zImage dtbs ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-

生成的设备树和镜像路径：

我的大学四年

Sun, 11 Jun 2023 02:45:00 +0000

神奇的Jeff Dean

Thu, 18 May 2023 13:29:42 +0000

很有一意思的一段趣闻；

参考：https://www.zhihu.com/question/582916722/answer/2951998203

During his own Google interview, Jeff Dean was asked the implications if P=NP were true. He said, “P = 0 or N = 1.” Then, before the interviewer had even finished laughing, Jeff examined Google’s public certificate and wrote the private key on the whiteboard.

当他被Google面试时，Jeff Dean被问及如果P=NP意味着什么。他说，“P=0 或者 N=1”。然后，在所有的面试官还没笑完之前，Jeff瞄了一眼Google的公共证书然后在白板上写上了对应的私钥。

Compilers don’t warn Jeff Dean. Jeff Dean warns compilers.

编译器从来不给Jeff编译警告，而是Jeff警告编译器。

The rate at which Jeff Dean produces code jumped by a factor of 40 in late 2000 when he upgraded his keyboard to USB 2.0.

C语言实现交换二进制数的任意两位

Mon, 17 Apr 2023 10:34:30 +0000

最近在用LED组成的数码管，由于位号硬件上有所改动，因而需要进行码值位之间的交换；

以下是一段C语言函数，实现将一个八位的二进制数的任意两位交换：

#include
/**
 * @brief   交换一个八位的二进制数的任意两位
 * @param x 一个八位的二进制数
 * @param i 要交换的两个位置
 * @param j 要交换的两个位置
 * @return  交换后的结果
 */
unsigned char swap_bits(unsigned char x, int i, int j)
{
    // 获取第i位和第j位的值
    unsigned char bit_i = (x >> i) & 1;
    unsigned char bit_j = (x >> j) & 1;
    // 如果第i位和第j位的值不同，那么交换它们
    if (bit_i ^ bit_j)
    {
        x ^= (1

基于esp32的手表

Wed, 12 Apr 2023 07:03:56 +0000

这个是小一的第六个正式版本了，这次是用ESP32作为主控的；

硬件

原理图

PCB

在线BOM

实物图

Kicad生成Gerber文件

Wed, 12 Apr 2023 02:16:43 +0000

这个是针对嘉立创打样的；

单击菜单栏【文档】 » 【绘制】，格式选择【Gerber】，各项设置如下截图所示。

配置以下选项：

然后点击绘制即可：

点击生成钻孔文件：

配置钻孔选项：

然后生成钻孔文件和映射文件即可：

将生成的文件打包就可以进行打样了；

PID进阶教程

Sun, 09 Apr 2023 04:47:04 +0000

PID精进教程；这篇文章的主要内容是如何改进初学者的PID控制器。文章中提到，初学者的PID控制器设计的目的是不规则地调用。这会导致两个问题：您无法从PID获得一致的行为，因为有时它被频繁调用，有时则没有。您需要进行额外的数学计算，以计算导数和积分，因为它们都依赖于时间的变化。作者提出了一种新的方法，称为“Proportional on Measurement”，可以解决这些问题。

任何编写自己的 PID 算法的人都可以看看我是如何做的，并可以从中学到他们需要的东西。

这将是一个艰难的过程，但我想我找到了一种不太痛苦的方式来解释我的代码。我将从所谓的“初学者的 PID”开始。然后我将逐步改进它，直到我们得到一个高效、健壮的 pid 算法。

PID的开始

这是初学PID的人都知道的公式：

Output=K_pe(t)+K_t\int{e(t)dt}+K_D{\frac{d}{dt}}e(t) Where:e=Setpoint-Input

公式(2)也就是指偏差e等于设定值和当前值的差别；

根据这个公式，大多数都能写出下面的代码：

/*working variables*/
unsigned long lastTime;
double Input, Output, Setpoint;
double errSum, lastErr;
double kp, ki, kd;
void Compute()
{
   /*How long since we last calculated*/
   unsigned long now = millis();
   double timeChange = (double)(now - lastTime);
  
   /*Compute all the working error variables*/
   double error = Setpoint - Input;
   errSum += (error * timeChange);
   double dErr = (error - lastErr) / timeChange;
  
   /*Compute PID Output*/
   Output = kp * error + ki * errSum + kd * dErr;
  
   /*Remember some variables for next time*/
   lastErr = error;
   lastTime = now;
}
  
void SetTunings(double Kp, double Ki, double Kd)
{
   kp = Kp;
   ki = Ki;
   kd = Kd;
}

Compute()被定期或不定期地调用，并且运行良好。不过，这个系列并不是关于“工作得很好”。如果我们要将这段代码变成与工业 PID 控制器相当的东西，我们必须解决一些问题：

基于Arduino的LVGL移植

Fri, 07 Apr 2023 05:47:41 +0000

这是一篇如何将LVGL移植到Arduino的教程(基于芯片ESP32 Pico D4)；

软件版本

这次实验使用的lvgl版本是8.1.1，要先配置好tft_espi，确保显示正常；如果要使用触摸屏设备，在移植之前要确保能获取到触摸数据；

工程配置

库安装

添加lvgl库，最好也添加lv_examples库，自带的例子虽然内容完全一样，但是并不能直接使用；

库安装

然后复制为lv_conf_template.h为lv_conf.h：

lv_conf.h创建

然后复制为lv_demo_conf_template.h为lv_demo_conf.h：

lv_demo_conf.h创建

配置文件

lv_conf.h

修改这几个地方；

启动lv_conf.h：

启动lv_conf

设置色深，一般都是16：

设置色深

启动自定义时钟，不设置的话只会显示第一帧不动：

启动自定义时钟

LV_DPI_DEF 注意这里，虽然LVGL的作者说这个没这么重要，但他会严重影响到LVGL的动画效果，你应该进行DPI的手动计算，例如240x280分辨率1.69英寸的屏幕，那么 DPI为：

LV_DPI_DEF =\frac{\sqrt{240*280} }{1.69} ≈ 153

LV_DPI_DEF配置

也可以使能日志打印：

使能日志打印

lv_demo_conf.h

修改这几个地方；

启动lv_demo_conf.h：

启动Demo

配置要运行的Demo：

Demo选择

自定义显示接口和外部输入接口

文件添加

在src文件夹下添加以下两个文件：

自定义接口

代码内容

my_lv_ports.cpp

#include "my_lv_ports.h"
#include "CST816T.h"
// TFT_eSPI tft = TFT_eSPI(screenWidth, screenHeight); /* TFT instance */
TFT_eSPI tft = TFT_eSPI();     /* TFT instance */
CST816T touch(19, 21, -1, 22); // sda, scl, rst, irq

// /*Read the touchpad*/
void my_touchpad_read(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
{
    bool FingerNum = 0;
    uint8_t gesture;
    uint16_t touchX, touchY;
    FingerNum = touch.getTouch(&touchX, &touchY, &gesture);
    if (FingerNum)
    {
        data->state = LV_INDEV_STATE_REL;
        data->point.x = touchX;
        data->point.y = touchY;
#if LV_USE_LOG != 0
        Serial.printf("Touch: x=%d y=%d mode=%d\r\n", touchX, touchY, gesture);
#endif
        FingerNum = 0;
    }
    else
    {
        data->state = LV_INDEV_STATE_PR;
    }
}
/* Display flushing */
void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area,
                   lv_color_t *color_p)
{
    uint32_t w = (area->x2 - area->x1 + 1);
    uint32_t h = (area->y2 - area->y1 + 1);

    tft.setSwapBytes(true);
    // tft.pushImageDMA(area->x1, area->y1, w, h, (uint16_t *)&color_p->full);
    tft.pushImage(area->x1, area->y1, w, h, (uint16_t *)&color_p->full);
    // tft.startWrite();
    // tft.setAddrWindow( area->x1, area->y1, w, h );
    // tft.pushColors( ( uint16_t * )&color_p->full, w * h, true );
    // tft.endWrite();

    lv_disp_flush_ready(disp);
}

#if LV_USE_LOG != 0
void my_print(const char *buf)
{
    Serial.printf("%s \r\n", buf);
}
#endif

void my_disp_init(void)
{
    // 绘图缓冲初始化
    //   static lv_disp_draw_buf_t draw_buf;
    //   static lv_color_t buf[screenWidth * 10];
    //   lv_disp_draw_buf_init(&draw_buf, buf, NULL, screenWidth * 10);

    static lv_disp_draw_buf_t draw_buf;
    static lv_color_t buf_2_1[screenWidth * 40]; /*A buffer for 10 rows*/
    static lv_color_t buf_2_2[screenWidth * 40]; /*An other buffer for 10
    rows*/
    lv_disp_draw_buf_init(&draw_buf, buf_2_1, buf_2_2,
                          screenWidth * 30); /*Initialize
                          the display buffer*/

    // TFT驱动初始化
    tft.begin(); /* TFT init */
    // tft.initDMA();
    tft.setRotation(0); /* Landscape orientation, flipped */

    // 设置LVGL显示设备
    static lv_disp_drv_t disp_drv;
    lv_disp_drv_init(&disp_drv);
    /*Change the following line to your display resolution*/
    disp_drv.hor_res = screenWidth;
    disp_drv.ver_res = screenHeight;
    disp_drv.flush_cb = my_disp_flush;
    disp_drv.draw_buf = &draw_buf;
    lv_disp_drv_register(&disp_drv);
    touch.begin();
    // 设置LVGL输入设备（电阻屏）
    static lv_indev_drv_t indev_drv;
    lv_indev_drv_init(&indev_drv);
    indev_drv.type = LV_INDEV_TYPE_POINTER;
    indev_drv.read_cb = my_touchpad_read;
    lv_indev_drv_register(&indev_drv);

// 设置LVGL串口输出设备（调试用）
#if LV_USE_LOG != 0
    lv_log_register_print_cb(my_print);
#endif
}

my_lv_ports.h

TODO

Tue, 04 Apr 2023 12:29:45 +0000

有空就会做的事；

记得翻译一下这篇文章

PID精进教程

完成否？否

创建于：2023年4月4日20:32:45 完成于：备注：

ESP32-PICO-D4开发记录

Sat, 01 Apr 2023 07:04:46 +0000

我这两天又翻出来了之前做的一个ESP32-Pico-D4的板子，之前测是发现会无限重启，结果现在再试，下进去一个新的程序就能用了，这里记录一下开发中遇到的问题；

Pico D4介绍

这个芯片资源挺多的，最主要的是内嵌了晶振和Flash，在板子布线方面容易了许多；

芯片特性

原理图设计

原理图设计参考

原理图参考

实物图片

重启问题

ESP32 启动时会有如下打印:

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)

其中 rst 简单说明如下:

PRO APP 源复位方式注释

0x01 0x01 芯片上电复位系统复位

0x10 0x10 RWDT 系统复位系统复位详见 ESP32 技术参考手册 WDT 章节

0x0F 0x0F 欠压复位系统复位详见 ESP32 技术参考手册 Power Management 章节

0x03 0x03 软件系统复位内核复位配置 RTC_CNTL_SW_SYS_RST 寄存器

0x05 0x05 Deep Sleep Reset 内核复位详见 ESP32 技术参考手册 Power Management 章节

0x07 0x07 MWDT0 全局复位内核复位详见 ESP32 技术参考手册 WDT 章节

docker初尝试

Sun, 19 Mar 2023 02:27:15 +0000

docker初体验；

docker常用命令

#docker常用命令:
1. 查看容器:
      docker ps
2. 查看镜像:
      docker images
3. 删除容器:
      docker rm 容器name
4. 删除镜像:
      docker rmi 镜像id
5. 创建容器:
      docker run --name dockermysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=654321 mysql:5.7.23
6. 启动容器:
      docker start 容器name #docker start dockermysql
7. 重启容器:
      docker restart dockermysql
8. 停止容器:
      docker stop dockermysql
9. 容器交互:
      docker exec -it dockermysql bash #或 docker attach dockermysql
10.退出交互:
      Ctrl+P,Ctrl+Q(Ctrl键一直保持按下)
11.设置开机自启:
      systemctl enable docker
12.容器设置自启,update命令:
      docker update --restart=always aeccnginx
13.启动docker
      systemctl start docker
14.重启docker
      systemctl restart docker

使用C和C++进行混合编程

Tue, 07 Mar 2023 08:53:27 +0000

在做毕设过程中，用到了八个相同的传感器，传感器的通信协议都是一样的，固然直接搞八个差不多的文件来驱动传感器是没问题的，但是有一种更简洁的方式，那就是使用C++，来复用通信程序；

参考：https://zhuanlan.zhihu.com/p/115068898

环境说明

使用的单片机芯片是STM32F103C6T6；

Keil编译器版本为AC6；

Keil的配置如下：

然后是将C++源文件配对的头文件改为使用C++编译器进行编译；

源码编写

注意把main文件的后缀也改为.cpp，否则会出错；

头文件：

/*
 * @Author       : fan-pengfei 2253770787@qq.com
 * @Date         : 2023-03-07 13:43:38
 * @LastEditors  : fan-pengfei 2253770787@qq.com
 * @LastEditTime : 2023-03-07 14:41:29
 * @FilePath     : \Core\Inc\ds18b20.h
 * @Description  :
 * Copyright (c) 2023 by ${git_name_email}, All Rights Reserved.
 */
#ifndef __DS18B20_H
#define __DS18B20_H

#include "main.h"
#include "tim.h"
class DS18B20_Class
{
private:
    GPIO_TypeDef *BSP_DS18B20_PORT;
    uint16_t BSP_DS18B20_PIN;
    float *Temp_Sum;
    uint8_t LOCATION;

public:
    DS18B20_Class(GPIO_TypeDef *BSP_DS18B20_PORT, uint16_t BSP_DS18B20_PIN, uint8_t LOCATION, float *Temp_data);
    void delay_us(uint16_t us);
    GPIO_PinState DS18B20_IN(void);
    void DS18B20_OUT_1(void);
    void DS18B20_OUT_0(void);
    void DS18B20_Mode_OUT_PP(void);
    void DS18B20_Mode_IN_NP(void);
    void DS18B20_Reset(void);
    uint8_t DS18B20_Presence(void);
    uint8_t DS18B20_ReadBit(void);
    uint8_t DS18B20_ReadByte(void);
    void DS18B20_WriteByte(uint8_t dat);
    void DS18B20_ReadId(uint8_t *ds18b20_id);
    void DS18B20_SkipRom(void);
    void DS18B20_MatchRom(void);
    uint8_t Init(void);
    float DS18B20_GetTemp_SkipRom(void);
    float DS18B20_GetTemp_MatchRom(uint8_t *ds18b20_id);
    void Start_Convert(void);
    void Get_Data(uint8_t ds18b20_id[64][8]);
};

extern "C"
{
    void User_DS18B20_Init(void);
    void User_Start_Convert(void);
    void User_Get_Data(void);
}
#endif

源文件：

/*
 * @Author       : fan-pengfei 2253770787@qq.com
 * @Date         : 2023-03-07 13:43:26
 * @LastEditors  : fan-pengfei 2253770787@qq.com
 * @LastEditTime : 2023-03-07 16:41:42
 * @FilePath     : \Core\Src\ds18b20.cpp
 * @Description  :
 * Copyright (c) 2023 by ${git_name_email}, All Rights Reserved.
 */
#include "ds18b20.h"
#include "main.h"
#include "DS18B20_ID.h"
extern float Temp_Sum[64];
void DS18B20_Class::delay_us(uint16_t us)
{
    tim_delay_us(us);
    // uint32_t delay;
    // delay = (1600 * us);
    // while (delay--)
    // {
    // }
}
GPIO_PinState DS18B20_Class::DS18B20_IN(void)
{
    return HAL_GPIO_ReadPin(BSP_DS18B20_PORT, BSP_DS18B20_PIN);
}
void DS18B20_Class::DS18B20_OUT_1(void)
{
    HAL_GPIO_WritePin(BSP_DS18B20_PORT, BSP_DS18B20_PIN, GPIO_PIN_SET);
}
void DS18B20_Class::DS18B20_OUT_0(void)
{
    HAL_GPIO_WritePin(BSP_DS18B20_PORT, BSP_DS18B20_PIN, GPIO_PIN_RESET);
}
/**
 * @brief DS18B20 输出模式
 */
void DS18B20_Class::DS18B20_Mode_OUT_PP(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = BSP_DS18B20_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(BSP_DS18B20_PORT, &GPIO_InitStruct);
}
/**
 * @brief DS18B20 输入模式
 */
void DS18B20_Class::DS18B20_Mode_IN_NP(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = BSP_DS18B20_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(BSP_DS18B20_PORT, &GPIO_InitStruct);
}
/**
 * @brief 主机给从机发送复位脉冲
 */
void DS18B20_Class::DS18B20_Reset(void)
{
    DS18B20_Mode_OUT_PP(); // 主机输出
    DS18B20_OUT_0();       // 主机至少产生 480us 的低电平复位信号
    delay_us(750);
    DS18B20_OUT_1(); // 主机在产生复位信号后，需将总线拉高
    // 从机接收到主机的复位信号后，会在 15 ~ 60 us 后给主机发一个存在脉冲
    delay_us(15);
}
/**
 * @brief  检测从机给主机返回的存在脉冲
 * @return 0：成功		1：失败
 */
uint8_t DS18B20_Class::DS18B20_Presence(void)
{
    uint8_t pulse_time = 0;
    DS18B20_Mode_IN_NP();                      // 主机设为输入
    while (DS18B20_IN() && (pulse_time = 100)
    {
        return 1;
    }
    else
    {
        pulse_time = 0;
    }
    while (!(DS18B20_IN()) && pulse_time = 240)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
/**
 * @brief 从DS18B20读取一个bit
 */
uint8_t DS18B20_Class::DS18B20_ReadBit(void)
{
    uint8_t dat;
    DS18B20_Mode_OUT_PP(); // 读 0 和读 1 的时间至少要大于 60 us
    DS18B20_OUT_0();       // 读时间的起始：必须由主机产生 > 1us > 1;
        // 写 0 和写 1 的时间至少要大于60us
        if (testb) // 当前位写 1
        {
            DS18B20_OUT_0();
            delay_us(5);     // 拉低发送写时段信号
            DS18B20_OUT_1(); // 读取电平时间保持高电平
            delay_us(65);
        }
        else // 当前位写 0
        {
            DS18B20_OUT_0(); // 拉低发送写时段信号
            delay_us(70);    // 读取电平时间保持低电平
            DS18B20_OUT_1();
            delay_us(2); // 恢复时间
        }
    }
}
/**
 * @brief  跳过匹配 DS18B20 ROM
 */
void DS18B20_Class::DS18B20_SkipRom(void)
{
    DS18B20_Reset();
    DS18B20_Presence();
    DS18B20_WriteByte(0XCC); /* 跳过 ROM */
}
/**
 * @brief  执行匹配 DS18B20 ROM
 */
void DS18B20_Class::DS18B20_MatchRom(void)
{
    DS18B20_Reset();
    DS18B20_Presence();
    DS18B20_WriteByte(0X55); /* 匹配 ROM */
}

DS18B20_Class::DS18B20_Class(GPIO_TypeDef *BSP_DS18B20_PORT, uint16_t BSP_DS18B20_PIN, uint8_t LOCATION, float *Temp_data)
{
    DS18B20_Class::BSP_DS18B20_PORT = BSP_DS18B20_PORT;
    DS18B20_Class::BSP_DS18B20_PIN = BSP_DS18B20_PIN;
    DS18B20_Class::LOCATION = LOCATION;
    DS18B20_Class::Temp_Sum = Temp_data;
}
uint8_t DS18B20_Class::Init(void)
{
    DS18B20_Mode_OUT_PP();
    DS18B20_OUT_1();
    DS18B20_Reset();
    return DS18B20_Presence();
}
/**
 * 存储的温度是16 位的带符号扩展的二进制补码形式
 * 当工作在12位分辨率时，其中5个符号位，7个整数位，4个小数位
 *
 *         |---------整数----------|-----小数 分辨率 1/(2^4)=0.0625----|
 * 低字节  | 2^3 | 2^2 | 2^1 | 2^0 | 2^(-1) | 2^(-2) | 2^(-3) | 2^(-4) |
 *
 *
 *         |-----符号位：0->正  1->负-------|-----------整数-----------|
 * 高字节  |  s  |  s  |  s  |  s  |    s   |   2^6  |   2^5  |   2^4  |
 *
 *
 * 温度 = 符号位 + 整数 + 小数*0.0625
 */
/**
 * @brief  在跳过匹配 ROM 情况下获取 DS18B20 温度值
 * @param  无
 * @retval 温度值
 */
float DS18B20_Class::DS18B20_GetTemp_SkipRom(void)
{
    uint8_t tpmsb, tplsb;
    int16_t s_tem;
    float f_tem;
    DS18B20_SkipRom();
    DS18B20_WriteByte(0X44); /* 开始转换 */
    DS18B20_SkipRom();
    DS18B20_WriteByte(0XBE); /* 读温度值 */
    tplsb = DS18B20_ReadByte();
    tpmsb = DS18B20_ReadByte();
    s_tem = tpmsb  要注意其中的`extern "C"`的用法；

### Main中调用：

> 注意main文件也是cpp后缀；

```c++
void main(void)
{
    User_DS18B20_Init();
    while (1)
    {
        User_Start_Convert();
        HAL_Delay(200); // 更新速率为200ms，等待转换结束
        User_Get_Data();
        int i = 0;
        while (i

使用C编写

![5a011b38ca2d1e989de04f32bb8c0e5](img-5.png)

使用C++编写

![4dbfdf38abe4f0d85cc7f98e4133007](img-6.png)

**C:**

Total RO  Size (Code + RO Data)
14016 (13.69kB)

Total RW  Size (RW Data + ZI Data)
2040 (1.99kB)

Total ROM Size (Code + RO Data + RW Data)
14464 (  14.13kB)

**C++:**

Total RO  Size (Code + RO Data)
11780 (11.50kB)

Total RW  Size (RW Data + ZI Data)
2864 (2.80kB)

Total ROM Size (Code + RO Data + RW Data)
12220 (  11.93kB)

> 相比较而言C用的ROM比较多一些，C++用的RAM比较多一些；

**可见在某些情况下，使用C++编写代码可以有效缩减代码体积，且代码更易懂；**

### microlib

使用C++编译的话，就没法再使用MicroLIB，因为MicroLIB为非标准的精简库，会与标准C++产生冲突；

### 中断服务程序

如果中断服务程序是异常的，因为stm32的中断入口矢量是按C的方式进入的，因此需要在整个文档的头部和末尾加上extern “C”{}用大括号把整个代码段扩住，这样中断就可以正常的进入了；

### Cubemx

Cubemx在生成头文件中已经加入了：

```c
#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
}
#endif

所以在不是其生成的文件中要注意extern "C"的使用；

ROS相关知识

Tue, 28 Feb 2023 08:56:52 +0000

做毕设用到了ROS，这里记录ROS相关知识；

语言基于Python，因为C++短时间学不起来，Python的话还能懂一些；

工作空间构建

创建一个新的文档夹我们创建一个新的文档夹作为新的工作空间的开始给每个新的工作空间创建一个新的文档夹是一个好习惯，取上面名字无关紧要，但是最好能从这个名字上看出这个工作空间是干什么的，例如main_ws，(主要工作空间)：

mkdir main_ws

将功能包放入src也是一个比较好的习惯，我们创建一个工作空间同时创建一个src文档夹，然后进入这个文档夹内：

mkdir main_ws/src
cd main_ws/src

与ROS1不同，ROS2的工作空间并不需要init；

自定义包

如何在ROS2中创建一个功能包呢？我们可以使用这个指令：

$ ros2 pkg create --build-type

在ros2命令中：

pkg：表示功能包相关的功能；
create：表示创建功能包；
build-type：表示新创建的功能包是C++还是Python的，如果使用C++或者C，那这里就跟ament_cmake，如果使用Python，就跟ament_python；
package_name：新建功能包的名字。

比如在终端中分别创建C++和Python版本的功能包：

cd ~/main_ws/src
ros2 pkg create --build-type ament_cmake learning_pkg_c               # C++
ros2 pkg create --build-type ament_python learning_pkg_python # Python

对于Python包：

只需要进到构建的包文件夹中，进入与上一层文件夹名字相同的包中即可，然后写入源文件；

然后修改package.xml文件：

from setuptools import setup

package_name = 'serial_test'

setup(
    name=package_name,
    version='0.0.0',
    packages=[package_name],
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='xioafei',
    maintainer_email='2253770787@qq.com',
    description='TODO: Package description',
    license='TODO: License declaration',
    tests_require=['pytest'],
    entry_points={
        'console_scripts': [
         'interface_object_pub  = serial_test.interface_object_pub:main',
        #  'interface_object_sub  = serial_test.interface_object_sub:main',
        ],
    },
)

编译功能包

在创建好的功能包中，我们可以继续完成代码的编写，之后需要编译和配置环境变量，才能正常运行：

在GDB下调试STM32的记录

Mon, 27 Feb 2023 12:04:31 +0000

基于VSCode使用GDB来调试STM32，我感觉比那个Keil还好用，而且更懂底层原理；

一、调试步骤：

准备工作

已经熟悉arm gcc工具链；

已经在win中安装好mingw或者arm-none-eabi-gcc工具；

具有合适的代码工程和编译脚本，且编译输出elf文档时，已添加-g选项来生成调试信息；

安装jlink调试工具和对应驱动；

有对应的硬件电路；

1、启动Jlink GDB Server

打开Jlink诸多工具中的Jlink GDB Server并配置好：

启动：

可以看到本地端口为2331，这个一会会用到；

然后就可以把这个窗口最小化了；

2、GDB调试

启动GDB程序：

arm-none-eabi-gdb.exe

然后按enter自动进入调试模式；

输入file H743_demo.elf加载调试文档：

然后输入target remote localhost:2331，连接gdb server，连接成功后，会在Jlink GDB server中显示对应的状态，如下所示：

输入monitor reset来复位MCU，从而让MCU处于确定的状态：

输入load往MCU中加载调试文档（是加载进flash,而不是ram），也就是常见的烧录过程：

输入break main设置main断点，让MCU执行到main中停止：

输入c持续运行直至运行到断点处：

HAL_Init();是main函数的第一行代码，停在这里；

再次输入c会继续运行；

若要打断持续运行的状态，只需要按下Ctrl+c即可；

3、需要注意的地方

每次程序重新编译都要执行一次load以加载新的elf文档；

如果不使用命令行，而是使用VSCODE中的调试功能，则也需要在程序更新的时候重新load一次；

二、常用命令

1、p(打印)

p+变量名：打印变量值：

2、s(单步运行)

s：单步运行；

并且可以用 breakpoint+行号进行断点设置；

3、l(列出)

列出当前位置前后共5行程序；

4、watch(变量监视)

Watchpoints 是用来告诉 GDB 停止执行某个程序的标记。Watchpoints 与数据相关联：放置监视点需要指定一个表达式来描述变量、多个变量或内存地址。

基于STM32的CMAKE模板

Mon, 27 Feb 2023 06:23:22 +0000

这是一个基于STM32单片机的模板；

示例中的单片机是STM32H743IIT6，调试器使用JlinkOB；

其中的各个参数可以参考使用STM32CubeMX生成的基于makefile的模板，且后续仍然可以使用STM32CubeMX进行底层代码的构建；

如果需要进行调试，可以先启动J-Link GDB Server，然后使用VSCode进行调试或者直接使用命令行进行调试；

# CMAKE_SYSTEM_NAME: 即你目标机target所在的操作系统名称，比如ARM或者Linux你就需要写"Linux";
# 如果Windows平台你就写"Windows",如果你的嵌入式平台没有相关OS你即需要写成"Generic";
# 只有当CMAKE_SYSTEM_NAME这个变量被设置了，CMake才认为此时正在交叉编译;
# 它会额外设置一个变量CMAKE_CROSSCOMPILING为TRUE;
set(CMAKE_SYSTEM_NAME Generic)

# CMAKE_SYSTEM_NAME和CMAKE_SYSTEM_PROCESSOR是交叉编译的时候必须指定的两个参数;
# 如果在cmake命令行定义了CMAKE_SYSTEM_NAME,就必须也定义CMAKE_SYSTEM_PROCESSOR;
set(CMAKE_SYSTEM_PROCESSOR cortex-m7)

#cmake最低版本
cmake_minimum_required(VERSION 3.1.0)

#编译工具
set(CROSS_COMPILE_PREFIX arm-none-eabi)
# 顾名思义，即C语言编译器，这里可以将变量设置成完整路径或者文档名;
# 设置成完整路径有一个好处就是CMake会去这个路径下去寻找编译相关的其他工具;
# 比如linker,binutils等，如果你写的文档名带有arm-elf等等前缀;
# CMake会识别到并且去寻找相关的交叉编译器;
set(CMAKE_C_COMPILER ${CROSS_COMPILE_PREFIX}-gcc)
set(CMAKE_CXX_COMPILER ${CROSS_COMPILE_PREFIX}-g++)
set(CMAKE_ASM_COMPILER ${CROSS_COMPILE_PREFIX}-gcc)
set(CMAKE_OBJCOPY ${CROSS_COMPILE_PREFIX}-objcopy)
set(CMAKE_OBJDUMP ${CROSS_COMPILE_PREFIX}-objdump)
set(CMAKE_SIZE ${CROSS_COMPILE_PREFIX}-size)

# CMake中的命令find_program用于查找程序(program)
# 会将查找到的文档路径存在CMakeCache.txt中
find_program(ARM_SIZE_EXECUTABLE ${CROSS_COMPILE_PREFIX}-size)
find_program(ARM_GDB_EXECUTABLE ${CROSS_COMPILE_PREFIX}-gdb)
find_program(ARM_OBJCOPY_EXECUTABLE ${CROSS_COMPILE_PREFIX}-objcopy)
find_program(ARM_OBJDUMP_EXECUTABLE ${CROSS_COMPILE_PREFIX}-objdump)

set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

# search for program/library/include in the build host directories
# 1、CMAKE_FIND_ROOT_PATH_MODE_PROGRAM: 对FIND_PROGRAM()起作用，
# 有三种取值，NEVER,ONLY,BOTH,
#   第一个表示不在你CMAKE_FIND_ROOT_PATH下进行查找，
#   第二个表示只在这个路径下查找，
#   第三个表示先查找这个路径，再查找全局路径，
# 对于这个变量来说，一般都是调用宿主机的程序，所以一般都设置成NEVER
#
# 2、CMAKE_FIND_ROOT_PATH_MODE_LIBRARY: 对FIND_LIBRARY()起作用，
# 表示在链接的时候的库的相关选项，因此这里需要设置成ONLY来保证我们的库是在交叉环境中找的.
#
# 3、CMAKE_FIND_ROOT_PATH_MODE_INCLUDE: 对FIND_PATH()和FIND_FILE()起作用，
# 一般来说也是ONLY,如果你想改变，一般也是在相关的FIND命令中增加option来改变局部设置
# 有NO_CMAKE_FIND_ROOT_PATH,ONLY_CMAKE_FIND_ROOT_PATH,BOTH_CMAKE_FIND_ROOT_PATH
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

#工程名称
# project命令用于指定cmake工程的名称
# 实际上，它还可以指定cmake工程的版本号（VERSION关键字）、
# 简短的描述（DESCRIPTION关键字）、
# 主页URL（HOMEPAGE_URL关键字）、
# 编译工程使用的语言（LANGUAGES关键字）。
project(H743_demo C CXX ASM)

set(target "${PROJECT_NAME}")
set(COMPILE_TOOLS  GCC)

# Target-specific flags
#型号
set(MCU_FAMILY STM32H743xx)
#布局文档
set(LINKER_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/STM32H743IITx_FLASH.ld)
#内核相关
set(CPU "-mcpu=cortex-m7")
set(FPU "-mfpu=fpv5-d16")
set(FLOAT_ABI "-mfloat-abi=hard")

#宏定义
add_definitions(-DUSE_HAL_DRIVER -DSTM32H743xx)

# 构建Release或者Debug版本
if(CMAKE_BUILD_TYPE MATCHES Debug)
    set(DBG_FLAGS "-g3 -gdwarf-2 -O0")
elseif(CMAKE_BUILD_TYPE MATCHES Release)
    set(DBG_FLAGS "-O3")
endif()

##file语法,前一个参数是固定的 后面一个参数自己定义
##添加文档的时候注意 相对路径和绝对路径
file(GLOB_RECURSE DRIVE_SRC
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_tim.c
    Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_tim_ex.c
    Core/Src/system_stm32h7xx.c
    startup_stm32h743xx.s
)
file(GLOB_RECURSE USER_SRC
    Core/Src/main.c
    Core/Src/gpio.c
    Core/Src/stm32h7xx_it.c
    Core/Src/stm32h7xx_hal_msp.c
)
# 添加源文件
set(SOURCE_FILES  ${DRIVE_SRC} ${USER_SRC})
#添加头文件路径
include_directories(
    ${CMAKE_CURRENT_SOURCE_DIR}/Core/Inc
    ${CMAKE_CURRENT_SOURCE_DIR}/Drivers/STM32H7xx_HAL_Driver/Inc
    ${CMAKE_CURRENT_SOURCE_DIR}/Drivers/STM32H7xx_HAL_Driver/Inc/Legacy
    ${CMAKE_CURRENT_SOURCE_DIR}/Drivers/CMSIS/Device/ST/STM32H7xx/Include
    ${CMAKE_CURRENT_SOURCE_DIR}/Drivers/CMSIS/Include
)

#芯片特性
set(MCU_FLAGS "${CPU} -mthumb ${FPU} ${FLOAT_ABI}")
# compiler: language specific flags CFLAGS
set(CMAKE_C_FLAGS   "${MCU_FLAGS} -std=gnu99 -Wall -fdata-sections -ffunction-sections ${DBG_FLAGS} " CACHE INTERNAL "C compiler flags")
#CPP
set(CMAKE_CXX_FLAGS "${MCU_FLAGS} -fno-rtti -fno-exceptions -fno-builtin -Wall -fdata-sections -ffunction-sections ${DBG_FLAGS} " CACHE INTERNAL "Cxx compiler flags")
#ASFLAGS
set(CMAKE_ASM_FLAGS "${MCU_FLAGS} -x assembler-with-cpp ${DBG_FLAGS} " CACHE INTERNAL "ASM compiler flags")
#LDFLAGS -mcpu=cortex-m0plus -mthumb
set(CMAKE_EXE_LINKER_FLAGS "${MCU_FLAGS} --specs=nosys.specs -specs=nano.specs -T${LINKER_SCRIPT} -Wl,-Map=${PROJECT_NAME}.map,--cref -Wl,--gc-sections" CACHE INTERNAL "Exe linker flags")
#要链接的库 对应makefile的 LIBS
set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "-lc -lm -lnosys" CACHE INTERNAL "Shared linker flags")

#先定义target 才可以添加define include
add_executable(${target}.elf ${SOURCE_FILES})

set(ELF_FILE ${PROJECT_BINARY_DIR}/${target}.elf)
set(HEX_FILE ${PROJECT_BINARY_DIR}/${target}.hex)
set(BIN_FILE ${PROJECT_BINARY_DIR}/${target}.bin)

add_custom_command(TARGET "${target}.elf" POST_BUILD
    COMMAND ${CMAKE_OBJCOPY} -Obinary ${ELF_FILE} ${BIN_FILE}
    COMMAND ${CMAKE_OBJCOPY} -Oihex  ${ELF_FILE} ${HEX_FILE}
    COMMENT "Building ${target}.bin and ${target}.hex"

    COMMAND ${CMAKE_COMMAND} -E copy ${HEX_FILE} "${CMAKE_CURRENT_BINARY_DIR}/${target}.hex"
    COMMAND ${CMAKE_COMMAND} -E copy ${BIN_FILE} "${CMAKE_CURRENT_BINARY_DIR}/${target}.bin"

    COMMAND ${CMAKE_SIZE} --format=berkeley ${target}.elf ${target}.hex
    COMMENT "Invoking: Cross ARM GNU Print Size"
)

使用方式：

CMAKE学习记录

Sat, 25 Feb 2023 13:27:27 +0000

CMAKE学习记录；

新建两个目录：

mkdir ./src
mkdir ./build

源文档编写：src/main.cpp

#include
int main()
{
    std::cout

![b562172f8e925c8150fa45bcbcb7b17](img-1.png)

然后输入以下命令进行编译和运行：

```bash
make
.\cmake_study.exe

STM32启动代码原理分析

Sat, 25 Feb 2023 07:54:51 +0000

STM32启动代码原理分析（底层技术）；

简述

ARM Cortex-M系列MCU的启动代码（使用汇编语言编程则不需要）主要做3件事情：

初始化并正确放置异常/中断矢量表；
分散加载；
初始化C语言运行环境（初始化堆栈以及C Library、浮点等）。

Cortex-M3内核规定，起始地址必须存放堆顶指针，而第二个地址则必须存放复位中断入口矢量地址，这样在Cortex-M3内核复位后，会自动从起始地址的下一个32位空间取出复位中断入口矢量，跳转执行复位中断服务程序。对比ARM7/ARM9内核，Cortex-M3内核则是固定了中断矢量表的位置而起始地址是可变化的。

源码分析

基于STM32F103C6T6的启动文件startup_stm32f103x6.s的简要说明如下：

;******************** (C) COPYRIGHT 2017 STMicroelectronics ********************
;* File Name          : startup_stm32f103x6.s
;* Author             : MCD Application Team
;* Description        : STM32F103x6 Devices vector table for MDK-ARM toolchain.
;*                      This module performs:
;*                      - Set the initial SP
;*                      - Set the initial PC == Reset_Handler
;*                      - Set the vector table entries with the exceptions ISR address
;*                      - Configure the clock system
;*                      - Branches to __main in the C library (which eventually
;*                        calls main()).
;*                      After Reset the Cortex-M3 processor is in Thread mode,
;*                      priority is Privileged, and the Stack is set to Main.
;******************************************************************************
;* @attention
;*
;* Copyright (c) 2017 STMicroelectronics.
;* All rights reserved.
;*
;* This software component is licensed by ST under BSD 3-Clause license,
;* the "License"; You may not use this file except in compliance with the
;* License. You may obtain a copy of the License at:
;*                        opensource.org/licenses/BSD-3-Clause
;*
;******************************************************************************

; Amount of memory (in bytes) allocated for Stack
; Tailor this value to your application needs
;  Stack Configuration
;    Stack Size (in Bytes)
;

Stack_Size		EQU     0x400       ;声明栈的大小为0x400字节

                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size  ;开辟一段大小为Stack_Size的内存空间作为栈
__initial_sp                        ;标号__initial_sp，表示栈空间顶地址。

;  Heap Configuration
;     Heap Size (in Bytes)
;

Heap_Size       EQU     0x200     ;声明栈的大小为0x200字节

                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base                       ;标号__heap_base，表示堆空间起始地址。
Heap_Mem        SPACE   Heap_Size ;开辟一段大小为Heap_Size的内存空间作为堆。
__heap_limit                      ;标号__heap_limit，表示堆空间结束地址。

;--------------------------------------------
;第一部分：
;启动代码最重要的工作是把异常中断向量表放到正确的Flash地址上
;把向量表定义为只读数据段，并导出向量表标号(Symbol)，让链接器识别此标号并根据分散加载文件正确的放置向量表
;__Vectors标号需要与分散加载文件合起来看，才会明白其真正的功能
;--------------------------------------------
                PRESERVE8         ;告诉编译器以8字节对齐。
                THUMB             ;告诉编译器使用THUMB指令集。

; Vector Table Mapped to Address 0 at Reset
                AREA    RESET, DATA, READONLY   ;声明权限为“READONLY”的名称为“RESET”的数据段
                                       ;（假设STM32从FLASH启动，则此中断矢量表起始地址即为0x8000000）
                EXPORT  __Vectors      ;将标号__Vectors声明为全局标号，这样外部文档就可以使用这个标号。
                EXPORT  __Vectors_End
                EXPORT  __Vectors_Size
;标号__Vectors，表示中断矢量表入口地址
;创建中断矢量表
;---------------------------------------
;第二部分:
;__initial_sp
;   1、栈顶指针地址，此语法跟MDK编译器的底层相关，是ARMCC编译器才能识别的语法
;      GCC与IAR的底层编译器ICCARM编译器不能识别;
;   2、__initial_sp 是一个链接器Image Symbol;
;   3、此处__initial_sp相当于是顶地址，或者此处直接把顶地址写到此处也行(如:0x20004000);
;   4、__initial_sp具体是多少，在此种写法下，是由分散加载文件决定的，下文会有详细论述;
;
;Reset_Handler:
;   1、Reset_Handler函数地址，此处相当于把Reset_Handler函数地址赋值给PC，即调用Reset_Handler函数;
;   2、此处也可以是其他函数，只是把复位函数放于此处最符合实际应用场景。
;      重要关键节点:
;   1、绝大多数cortex-M微控制器(M0、M3、M4都是这样)复位后先进入厂商BOOTROM，此时所有用户行为均无法介入处理器;
;   2、厂商BOOTROM(有些厂商会有其他名称来称呼此功能) 主要负责处理一些芯片最初级初始化、
;      加密以及一些对MCU的差异化设置等工作:
;   3、BOOTROM顺利完成后，MCu控制权会交给用户，即启动代码;
;   4、启动代码(运行汇编语言则不需要此启动代码)，最重要的工作在于设置MSP (主堆栈指针)以及PC(程序计数器)的值;
;   5、Cortex-M微控制器会默认把0x00000000地址里面的值设置为MSP的值，0x00000004地址里面的值设置为PC的值;
;   6、5中的默认地址可以通过修改Cortex-M中的VTOR寄存器来重新映射，比如改到0x20000000地址或其他;
;
;关于Exception(异常) 与Interrupt (中断) 的区别说明
;   1、Exception(异常)与Interrupt(中断)是不同的，是两个不同的概念，很多人会混淆两者,
;      把他们都按照中断来看待，这是错误的;
;   2、Exception(异常)是向量表的前16个向量，其优先级为负数，高于所有中断，而且不可调整优先级也不可关闭,
;      可以打断正常程序与Interrupt(中断) 的运行:
;   3、从第16个向量以后才是Interrupt(中断)，可以设置优先级，不用时可以关闭，但优先级永远低于Exception(异常);
;   4、从这里大家就可以理解Pendsy Handler与svsTick Handler为什么会被用于嵌入式操作系统，
;      因为其优先级高于所有中断,可以确保操作系统拥有高于普通用户程序执行的超级权限,
;      SVC_Handler有时也会用于操作系统，原理相同;
;   5、用户应用程序应尽量避免使用Exception(异常);
;---------------------------------------
__Vectors       DCD     __initial_sp               ; Top of Stack  栈顶地址
                DCD     Reset_Handler              ; Reset Handler 复位向量
                DCD     NMI_Handler                ; NMI Handler
                DCD     HardFault_Handler          ; Hard Fault Handler
                DCD     MemManage_Handler          ; MPU Fault Handler
                DCD     BusFault_Handler           ; Bus Fault Handler
                DCD     UsageFault_Handler         ; Usage Fault Handler
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     SVC_Handler                ; SVCall Handler
                DCD     DebugMon_Handler           ; Debug Monitor Handler
                DCD     0                          ; Reserved
                DCD     PendSV_Handler             ; PendSV Handler 操作系统会用到的异常向量
                DCD     SysTick_Handler            ; SysTick Handler 操作系统会用到的心跳定时器异常向量(没有操作系统时可以用作普通定时器中断)
;---------------------------------------
;第三部分:
;   1、这里开始是中断向量表;
;   2、各个向量的顺序是芯片设计的时候就定义好的，不能更改;
;---------------------------------------
                ; External Interrupts
                DCD     WWDG_IRQHandler            ; Window Watchdog
                DCD     PVD_IRQHandler             ; PVD through EXTI Line detect
                DCD     TAMPER_IRQHandler          ; Tamper
                DCD     RTC_IRQHandler             ; RTC
                DCD     FLASH_IRQHandler           ; Flash
                DCD     RCC_IRQHandler             ; RCC
                DCD     EXTI0_IRQHandler           ; EXTI Line 0
                DCD     EXTI1_IRQHandler           ; EXTI Line 1
                DCD     EXTI2_IRQHandler           ; EXTI Line 2
                DCD     EXTI3_IRQHandler           ; EXTI Line 3
                DCD     EXTI4_IRQHandler           ; EXTI Line 4
                DCD     DMA1_Channel1_IRQHandler   ; DMA1 Channel 1
                DCD     DMA1_Channel2_IRQHandler   ; DMA1 Channel 2
                DCD     DMA1_Channel3_IRQHandler   ; DMA1 Channel 3
                DCD     DMA1_Channel4_IRQHandler   ; DMA1 Channel 4
                DCD     DMA1_Channel5_IRQHandler   ; DMA1 Channel 5
                DCD     DMA1_Channel6_IRQHandler   ; DMA1 Channel 6
                DCD     DMA1_Channel7_IRQHandler   ; DMA1 Channel 7
                DCD     ADC1_2_IRQHandler          ; ADC1_2
                DCD     USB_HP_CAN1_TX_IRQHandler  ; USB High Priority or CAN1 TX
                DCD     USB_LP_CAN1_RX0_IRQHandler ; USB Low  Priority or CAN1 RX0
                DCD     CAN1_RX1_IRQHandler        ; CAN1 RX1
                DCD     CAN1_SCE_IRQHandler        ; CAN1 SCE
                DCD     EXTI9_5_IRQHandler         ; EXTI Line 9..5
                DCD     TIM1_BRK_IRQHandler        ; TIM1 Break
                DCD     TIM1_UP_IRQHandler         ; TIM1 Update
                DCD     TIM1_TRG_COM_IRQHandler    ; TIM1 Trigger and Commutation
                DCD     TIM1_CC_IRQHandler         ; TIM1 Capture Compare
                DCD     TIM2_IRQHandler            ; TIM2
                DCD     TIM3_IRQHandler            ; TIM3
                DCD     0                          ; Reserved
                DCD     I2C1_EV_IRQHandler         ; I2C1 Event
                DCD     I2C1_ER_IRQHandler         ; I2C1 Error
                DCD     0                          ; Reserved
                DCD     0                          ; Reserved
                DCD     SPI1_IRQHandler            ; SPI1
                DCD     0                          ; Reserved
                DCD     USART1_IRQHandler          ; USART1
                DCD     USART2_IRQHandler          ; USART2
                DCD     0                          ; Reserved
                DCD     EXTI15_10_IRQHandler       ; EXTI Line 15..10
                DCD     RTC_Alarm_IRQHandler        ; RTC Alarm through EXTI Line
                DCD     USBWakeUp_IRQHandler       ; USB Wakeup from suspend
__Vectors_End

__Vectors_Size  EQU  __Vectors_End - __Vectors
;---------------------------------------
;第四部分:
;这部分开始可以称作Reset Handler实体，芯片上电后，经过BOOTROM后进入的用户可控最开始处的地方;
;   1、如果想让Mcu正常使用c语言，务必在此处调用 main函数;
;   2、__main() 不是main() 两者有着本质性的区别;
;   3、__main()是c Library中的函数，Kei1开发环境中自带的c Library中的函数;
;   4、main()是被 __main()调用的，__main()工作完成后最后一步就是调用main();
;   5、__main()被调用之前，可以根据需要插入一个或多个其他功能函数;
;---------------------------------------
                AREA    |.text|, CODE, READONLY             ;定义只读的代码段

; Reset handler routine
;复位中断服务程序，PROC…ENDP结构表示程序的开始和结束。
Reset_Handler    PROC
                 EXPORT  Reset_Handler             [WEAK]   ;声明复位中断矢量Reset_Handler为全局属性
                                                            ;这样外部文档就可以调用此复位中断服务。
     IMPORT  __main                                         ;声明__main标号。
     IMPORT  SystemInit                                     ;声明SystemInit标号。
                 LDR     R0, =SystemInit                    ;跳转SystemInit地址执行
                 BLX     R0
                 LDR     R0, =__main                        ;跳转__main地址执行
                 BX      R0
                 ENDP

; Dummy Exception Handlers (infinite loops which can be modified)
;---------------------------------------------------------------
;第五部分:
;   1、[weak]指定了一个这个函数为"弱函数”;
;   2、这些中断服务函教定义成弱函数的意义是，当中断出现时，需要有一个中断服务函数予以响应，但真实的
;      用户程序往往只会使用一部分中断，甚至不使用中断，所以以下这些函数给出了异常/中断服务函数的
;      默认实现，很简单，默认实现就是死循环汇编中的"B."语句,相当于while(1);因为不知道用户是否会
;      用到多少中断，但这些服务函数又很重要，所以就把这些函数都"实现"并声明为弱函数;
;   3、弱函数的意思是如果用户定义了同样名称的另一个函数，那么默认实现的弱函数就会被覆盖，比如
;      HardFault_Handler异常在下面有一个默认的实现，但这种默认的实现不能满足我的需要的时候，我可以
;      再重新定义一个HardEault Handler函数这个新定义的HardFault_Handler函数会覆盖原有的被声明
;      为[WEAK]的弱函数;
;   4、有很多种适合使用弱函数的场合，默认的异常/中断服务函数只是一种应用场景;
;   5、在C语言中声明弱函数是在函数后加“__attribute((weak))”;
;----------------------------------------------------------------
NMI_Handler     PROC
                EXPORT  NMI_Handler                [WEAK]
                B       .
                ENDP
HardFault_Handler\
                PROC
                EXPORT  HardFault_Handler          [WEAK]
                B       .
                ENDP
MemManage_Handler\
                PROC
                EXPORT  MemManage_Handler          [WEAK]
                B       .
                ENDP
BusFault_Handler\
                PROC
                EXPORT  BusFault_Handler           [WEAK]
                B       .
                ENDP
UsageFault_Handler\
                PROC
                EXPORT  UsageFault_Handler         [WEAK]
                B       .
                ENDP
SVC_Handler     PROC
                EXPORT  SVC_Handler                [WEAK]
                B       .
                ENDP
DebugMon_Handler\
                PROC
                EXPORT  DebugMon_Handler           [WEAK]
                B       .
                ENDP
PendSV_Handler  PROC
                EXPORT  PendSV_Handler             [WEAK]
                B       .
                ENDP
SysTick_Handler PROC
                EXPORT  SysTick_Handler            [WEAK]
                B       .
                ENDP

Default_Handler PROC

                EXPORT  WWDG_IRQHandler            [WEAK]
                EXPORT  PVD_IRQHandler             [WEAK]
                EXPORT  TAMPER_IRQHandler          [WEAK]
                EXPORT  RTC_IRQHandler             [WEAK]
                EXPORT  FLASH_IRQHandler           [WEAK]
                EXPORT  RCC_IRQHandler             [WEAK]
                EXPORT  EXTI0_IRQHandler           [WEAK]
                EXPORT  EXTI1_IRQHandler           [WEAK]
                EXPORT  EXTI2_IRQHandler           [WEAK]
                EXPORT  EXTI3_IRQHandler           [WEAK]
                EXPORT  EXTI4_IRQHandler           [WEAK]
                EXPORT  DMA1_Channel1_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel2_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel3_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel4_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel5_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel6_IRQHandler   [WEAK]
                EXPORT  DMA1_Channel7_IRQHandler   [WEAK]
                EXPORT  ADC1_2_IRQHandler          [WEAK]
                EXPORT  USB_HP_CAN1_TX_IRQHandler  [WEAK]
                EXPORT  USB_LP_CAN1_RX0_IRQHandler [WEAK]
                EXPORT  CAN1_RX1_IRQHandler        [WEAK]
                EXPORT  CAN1_SCE_IRQHandler        [WEAK]
                EXPORT  EXTI9_5_IRQHandler         [WEAK]
                EXPORT  TIM1_BRK_IRQHandler        [WEAK]
                EXPORT  TIM1_UP_IRQHandler         [WEAK]
                EXPORT  TIM1_TRG_COM_IRQHandler    [WEAK]
                EXPORT  TIM1_CC_IRQHandler         [WEAK]
                EXPORT  TIM2_IRQHandler            [WEAK]
                EXPORT  TIM3_IRQHandler            [WEAK]
                EXPORT  I2C1_EV_IRQHandler         [WEAK]
                EXPORT  I2C1_ER_IRQHandler         [WEAK]
                EXPORT  SPI1_IRQHandler            [WEAK]
                EXPORT  USART1_IRQHandler          [WEAK]
                EXPORT  USART2_IRQHandler          [WEAK]
                EXPORT  EXTI15_10_IRQHandler       [WEAK]
                EXPORT  RTC_Alarm_IRQHandler        [WEAK]
                EXPORT  USBWakeUp_IRQHandler       [WEAK]
;---------------------------------------------------
;第六部分
;   这部分比较简单，看一下第五部分的代码就可以理解下面的部分;
;---------------------------------------------------
WWDG_IRQHandler
PVD_IRQHandler
TAMPER_IRQHandler
RTC_IRQHandler
FLASH_IRQHandler
RCC_IRQHandler
EXTI0_IRQHandler
EXTI1_IRQHandler
EXTI2_IRQHandler
EXTI3_IRQHandler
EXTI4_IRQHandler
DMA1_Channel1_IRQHandler
DMA1_Channel2_IRQHandler
DMA1_Channel3_IRQHandler
DMA1_Channel4_IRQHandler
DMA1_Channel5_IRQHandler
DMA1_Channel6_IRQHandler
DMA1_Channel7_IRQHandler
ADC1_2_IRQHandler
USB_HP_CAN1_TX_IRQHandler
USB_LP_CAN1_RX0_IRQHandler
CAN1_RX1_IRQHandler
CAN1_SCE_IRQHandler
EXTI9_5_IRQHandler
TIM1_BRK_IRQHandler
TIM1_UP_IRQHandler
TIM1_TRG_COM_IRQHandler
TIM1_CC_IRQHandler
TIM2_IRQHandler
TIM3_IRQHandler
I2C1_EV_IRQHandler
I2C1_ER_IRQHandler
SPI1_IRQHandler
USART1_IRQHandler
USART2_IRQHandler
EXTI15_10_IRQHandler
RTC_Alarm_IRQHandler
USBWakeUp_IRQHandler

                B       .

                ENDP

                ALIGN

;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
;IF…ELSE…ENDIF结构，判断是否使用DEF:__MICROLIB（此处为不使用）。
;若使用DEF:__MICROLIB，则将__initial_sp，__heap_base，__heap_limit
;亦即栈顶地址，堆始末地址赋予全局属性，使外部程序可以使用。
                 IF      :DEF:__MICROLIB

                 EXPORT  __initial_sp
                 EXPORT  __heap_base
                 EXPORT  __heap_limit

                 ELSE

                 IMPORT  __use_two_region_memory    ;定义全局标号__use_two_region_memory。
                 EXPORT  __user_initial_stackheap   ;声明全局标号__user_initial_stackheap，
                                                    ;这样外程序也可调用此标号

__user_initial_stackheap                    ;标号__user_initial_stackheap，表示用户堆栈初始化程序入口
                 ;分别保存栈顶指针和栈大小，堆始地址和堆大小至R0，R1，R2，R3寄存器。
                 LDR     R0, =  Heap_Mem
                 LDR     R1, =(Stack_Mem + Stack_Size)
                 LDR     R2, = (Heap_Mem +  Heap_Size)
                 LDR     R3, = Stack_Mem
                 BX      LR

                 ALIGN
                 ENDIF
                 END;程序完毕
;************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE*****

部分解释

以上便是STM32的启动代码的完整解析，接下来对几个小地方做解释：

STM32的启动过程

Sat, 25 Feb 2023 07:48:13 +0000

STM32单片机是如何从上电运行到main()函数的；

用三张图片基本就能理解了：

参考： https://blog.csdn.net/weixin_39118482/article/details/79508747?spm=1001.2014.3001.5502 https://www.modb.pro/db/548699 https://www.cnblogs.com/yucloud/p/stm32_SystemInit_to_main.html

1、函数的调用过程：

2、启动流程1（使用标准库，不使用Microlib）

如下图：

3、启动流程2（使用Microlib）

microlib 是缺省 C 库的备选库。它旨在与需要装入到极少量内存中的深层嵌入式应用程序配合使用。这些应用程序不在操作系统中运行。 microlib 进行了高度优化以使代码变得很小。它的功能比缺省 C 库少，并且根本不具备某些 ISOC 特性。某些库函数的运行速度也比较慢，例如， memcpy() 。 microlib与缺省C库之间的主要差异是： microlib不符合ISO C库标准。不支持某些ISO特性，并且其他特性具有的功能也较少； microlib不符合IEEE 754二进制浮点算法标准； microlib进行了高度优化以使代码变得很小；无法对区域设置进行配置。缺省C区域设置是唯一可用的区域设置；不能将main()声明为使用参数，并且不能返回内容；不支持stdio，但未缓冲的stdin、stdout和stderr除外； microlib对C99函数提供有限的支持； microlib不支持操作系统函数； microlib不支持与位置无关的代码； microlib不提供互斥锁来防止非线程安全的代码； microlib不支持宽字符或多字节字符串；与stdlib不同，microlib不支持可选择的单或双区内存模型。microlib只提供双区内存模型，即单独的堆栈和堆区。

启动流程如下图：

4、其他

关于stm32的启动文件： https://www.fan-pengfei.top/2023/02/25/STM32%E5%90%AF%E5%8A%A8%E4%BB%A3%E7%A0%81%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90/#more

分散加载文档

Sat, 25 Feb 2023 04:38:38 +0000

分散加载（scatter）文档是一个文本文档，它可以用来描述ARM连接器生成映像文档时所需要的信息；参考：https://blog.csdn.net/KXue0703/article/details/114018759

一、基础知识

为了充分理解分散加载文档的魅力，需要对工程编译后的内容有详细的了解。 Keil 编译后的内容如下所示：

Code：为程序代码部分；
RO-Data：表示程序定义的常量及 const 型数据；
RW-Data：表示已经初始化的静态变量，变量有初值；
ZI-Data：表示未初始化的静态变量，变量无初值；

当 Keil 工程编译完成后，查看其 map 文档，可得到结果如下程序清单：

Code (inc. data)   RO Data    RW Data    ZI Data      Debug

4194        230        714         16       1640      72715   Grand Totals
4194        230        714         16       1640      72715   ELF Image Totals
4194        230        714         16          0          0   ROM Totals

Total RO  Size (Code + RO Data)                 4908 (4.79kB)
Total RW  Size (RW Data + ZI Data)              1656 (1.62kB)
Total ROM Size (Code + RO Data + RW Data)       4924 (4.81kB)

由map文档可以看出： ROM Size = Code＋RO-Data＋RW-Data = 4.81kB； RAM Size = RW-Data＋ZI-Data = 1.62kB；

git中的rebase用法小结

Wed, 22 Feb 2023 07:28:48 +0000

今天用到了git rebase命令来进行合并两次提交，顺带梳理下rebase命令的用法；参考：https://www.jianshu.com/p/4a8f4af4e803

rebase在git中是一个非常有魅力的命令，使用得当会极大提高自己的工作效率；相反，如果乱用，会给团队中其他人带来麻烦。它的作用简要概括为：可以对某一段线性提交历史进行编辑、删除、复制、粘贴；因此，合理使用rebase命令可以使我们的提交历史干净、简洁！

前提：不要通过rebase对任何已经提交到公共仓库中的commit进行修改（你自己一个人玩的分支除外）；

一、合并多个commit为一个完整commit

当我们在本地仓库中提交了多次，在我们把本地提交push到公共仓库中之前，为了让提交记录更简洁明了，我们希望把如下分支B、C、D三个提交记录合并为一个完整的提交，然后再push到公共仓库。

现在我们在测试分支上添加了四次提交，我们的目标是把最后三个提交合并为一个提交：

这里我们使用命令:

git rebase -i  [startpoint]  [endpoint]

其中-i的意思是--interactive，即弹出交互式的界面让用户编辑完成合并操作，[startpoint] [endpoint]则指定了一个编辑区间，如果不指定[endpoint]，则该区间的终点默认是当前分支HEAD所指向的commit(注：该区间指定的是一个前开后闭的区间)。在查看到了log日志后，我们运行以下命令：

git rebase -i 36224db

或:

git rebase -i HEAD~3

然后我们会看到如下界面:

上面未被注释的部分列出的是我们本次rebase操作包含的所有提交，下面注释部分是git为我们提供的命令说明。每一个commit id 前面的pick表示指令类型，git 为我们提供了以下几个命令:

pick：保留该commit（缩写:p） reword：保留该commit，但我需要修改该commit的注释（缩写:r） edit：保留该commit, 但我要停下来修改该提交(不仅仅修改注释)（缩写:e） squash：将该commit和前一个commit合并（缩写:s） fixup：将该commit和前一个commit合并，但我不要保留该提交的注释信息（缩写:f） exec：执行shell命令（缩写:x） drop：我要丢弃该commit（缩写:d）

根据我们的需求，我们将commit内容编辑如下:

然后是注释修改界面:

编辑完保存即可完成commit的合并了：

二、将某一段commit粘贴到另一个分支上

当我们项目中存在多个分支，有时候我们需要将某一个分支中的一段提交同时应用到其他分支中，就像下图：

我们希望将develop分支中的C~E部分复制到master分支中，这时我们就可以通过rebase命令来实现（如果只是复制某一两个提交到其他分支，建议使用更简单的命令:git cherry-pick）。

在实际模拟中，我们创建了master和develop两个分支:

master分支:

develop分支:

我们使用命令的形式为:

git rebase [startpoint] [endpoint] --onto [branchName]

其中，[startpoint] [endpoint]仍然和上一个命令一样指定了一个编辑区间(前开后闭)，--onto的意思是要将该指定的提交复制到哪个分支上。

所以，在找到C(90bc0045b)和E(5de0da9f2)的提交id后，我们运行以下命令：

git  rebase 90bc0045b^ 5de0da9f2 --onto master

注:因为[startpoint] [endpoint]指定的是一个前开后闭的区间，为了让这个区间包含C提交，我们将区间起始点向后退了一步。

单总线挂载多个DS18B20并读取温度

Wed, 22 Feb 2023 03:15:35 +0000

当需要同时读取多个点的温度数据时，DS18B20就是一个很好的选择，不仅精度高，而且还可以单总线挂载多个传感器以节省IO口的使用；

初始化函数

DS18B20的通信协议为单总线通信协议；

首先由主机发送一个复位脉冲约480-960us；然后总线被拉高；在15-60us之后传感器向单片机发送一个约60-240us的存在脉冲，然后总线被拉高。

/**
 * @brief 主机给从机发送复位脉冲
 */
static void DS18B20_Reset(void)
{
    DS18B20_Mode_OUT_PP(); // 主机输出
    DS18B20_OUT_0; // 主机至少产生 480us 的低电平复位信号
    delay_us(750);
    DS18B20_OUT_1; // 主机在产生复位信号后，需将总线拉高
    // 从机接收到主机的复位信号后，会在 15 ~ 60 us 后给主机发一个存在脉冲
    delay_us(15);
}

/**
 * @brief  检测从机给主机返回的存在脉冲
 * @return 0：成功		1：失败
 */
static uint8_t DS18B20_Presence(void)
{
    uint8_t pulse_time = 0;
    DS18B20_Mode_IN_NP(); // 主机设为输入
    // 等待存在脉冲的到来，存在脉冲为一个 60 ~ 240 us 的低电平信号
    // 如果存在脉冲没有来则做超时处理，从机接收到主机的复位信号后，会在 15 ~ 60 us 后给主机发一个存在脉冲
    while (DS18B20_IN && (pulse_time = 100)
    {
        return 1;
    }
    else
    {
        pulse_time = 0;
    }
    // 响应脉冲（低电平）到来，且存在的时间不能超过 240 us
    while (!(DS18B20_IN) && pulse_time = 240)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
/**
 * @brief  DS18B20 初始化函数
 * @reurn  0：成功		1：失败
 */
uint8_t DS18B20_Init(void)
{
    DS18B20_Mode_OUT_PP();
    DS18B20_OUT_1;
    DS18B20_Reset();
    return DS18B20_Presence();
}

配置写函数

当主机将数据线从高逻辑级别拉到低逻辑级别时，将启动写入时隙。有两种类型的写时槽：写1时槽和写0时槽。所有写入时隙的持续时间必须至少为60µs，且每个写入周期之间的恢复时间至少为1µs以上。在DQ线下降后，DS18B20在15µs到60µs的窗口中对DQ线进行采样。

如何用7个IO口驱动42个LED

Tue, 21 Feb 2023 10:52:40 +0000

尽量用较少的IO口来驱动较多的LED灯；

当IO口数量较少，而又需要驱动较多的LED灯时，就需要想办法通过修改硬件或者软件的方案来进行；

硬件方案的话，就是用串转并芯片例如74HC595或者其他的数码管驱动芯片来控制，当然会增加硬件成本，如果只是用在个人项目中，小小的成本增加并没有什么，但是如果是用在量产项目中，小小的成本增加就会吃掉一大部分盈利；

所以尽量还是使用软件方案，并不需要什么74HC595芯片；

下面介绍的这种方法叫做查理复用：

查理复用（Charlieplex）是一种在驱动大量LED时有效地节约IO口的方法，理论上可以用N个IO驱动N*(N-1)个LED，也有接入二极管用来做按键检测的，理论上可实现用N个IO驱动N*(N-1)个按键；因而7个脚用满理论上可管理是42个LED，极大节省了IO口的使用；

但是对单片机的IO口有一个要求，也就是这种LED是由单片机I/O口直接驱动，I/O口要在工作在3态（高、低电平和高阻）；

使用六个IO口驱动30个LED的原理图如下（第六行并未完整画出）：

可以在程序里面每次间隔1ms，扫描一行，总共扫描6行后（6ms），一帧完整就画面结束了，也是利用人眼的视觉暂留画面；一定要记得，每行扫描的时候，需要亮灯的高低电平点亮，不亮灯的IO口一定要设为悬浮（高阻模式）。

如何用一个IO口检测两个按键的状态

Tue, 21 Feb 2023 10:52:12 +0000

用单个IO口来检测两个按键的状态；

一、ADC方案

上面是原理图，这个方案很好理解，主要就是利用电阻分压原理来判断多个按键被按下的状态，如果ADC的位数足够多，可以判断的按键数也会很多；

因为原理很简单，在这里就不再多说；

二、非ADC方案

这个方案适用于无ADC引脚或者ADC引脚被其他外设占用的情况，只以单IO口检测两个按键的状态的方案为例；

原理图如下所示：

EN是单片机内部的上拉使能开关，S1和S2是待检测的按键；

通过查阅STM32F103C8T6数据手册可以得知：

内部的上拉电阻阻值等效为40K欧姆电阻，高低电平的范围也在数据手册中有给出：

当MCU供电为3.3V时候：

IO口低电平电压范围：-0.5-0.8V；
IO口高电平电压范围： 2.0-3.8V；

因此得到最开始的检测电路；但有两个注意事项：

这里特别要注意在使用该电路时，电路参数须满足MCU的IO口高低电平的电气特性要求；
电路如果需要具备两个按键同时按的功能要求，需自行调整电路，该电路参数不满足该要求；

电路分析如下：

当EN 闭合时： S1 按下时， V_IO 接近0V，此时IO口为低电平。 S2 按下时， V_IO = 3.3V * R103 / (R+R103) V_IO = 3.3V * 510K/ (510K+（40K//2M）) = 3.06V 此时IO口为高电平。
当EN 断开时： S1 按下时， V_IO 接近0V，此时IO口为低电平。 S2 按下时， V_IO = 3.3V * R103 / (R+R103) V_IO = 3.3V * 510K/ (510K+ 2M) = 0.67V 此时IO口为低电平。

如何写好CommitMessage

Sat, 18 Feb 2023 14:06:23 +0000

翻译的一篇文章； Commit messages matter. Here’s how to write them well. 提交的备注信息很重要，这里将教给你如何写好它们.

简介：为什么好的提交信息很重要

如果你随机浏览任何一个 Git 存储库的日志，你可能会发现它的提交消息或多或少是一团糟。

例如，下面是我早期致力于 Spring 时的提交信息：

$ git log --oneline -5 --author cbeams --before "Fri Mar 26 2009"
e5f4b49 Re-adding ConfigurationPostProcessorTests after its brief removal in r814. @Ignore-ing the testCglibClassesAreLoadedJustInTimeForEnhancement() method as it turns out this was one of the culprits in the recent build breakage. The classloader hacking causes subtle downstream effects, breaking unrelated tests. The test method is still useful, but should only be run on a manual basis to ensure CGLIB is not prematurely classloaded, and should not be run as part of the automated build.
2db0f12 fixed two build-breaking issues: + reverted ClassMetadataReadingVisitor to revision 794 + eliminated ConfigurationPostProcessorTests until further investigation determines why it causes downstream tests to fail (such as the seemingly unrelated ClassPathXmlApplicationContextTests)
147709f Tweaks to package-info.java files
22b25e0 Consolidated Util and MutableAnnotationUtils classes into existing AsmUtils
7f96f57 polishing

啊哈，然后将其与来自同一存储库的这些最近的提交进行比较：

与或非等逻辑运算在程序中的应用

Tue, 14 Feb 2023 11:56:02 +0000

今天写代码的时候再次用到了与或非等逻辑运算符来完成一些二进制处理应用，总结记录一下；

一、缘起

以下是一个显示板的原理图，由于LED数量较多，因此在LED控制方案的选择上是选用了一块串转并的芯片74HC595；

对于74HC595的使用在这里就不再赘述；

74HC595串转并是转出8个输出端，再加上三个直接连接单片机引脚的COM端，理论上是可以很容易控制24个LED灯亮灭，就像是控制三个数码管一样，利用人眼的暂留现象，就可以使这24个LED灯的亮灭随意组合；

每一个COM端和8个LED组成一个组合，然后轮询点亮这三组LED，速度够快的话，就能看到三组LED被同时点亮；

二、解决

为了消除残影问题，在每一组的LED点亮后，应该马上写入使LED全部熄灭的命令，以消除可能会出现的残影问题；

首先定义三个uint8_t变量，例如代码中的LED_NUM1、LED_NUM2、LED_NUM3，然后通过控制COM端，分别向每组LED中写入这三个数据：

第一组 COM引脚排布：100 待写入74HC595中的数据：LED_NUM1

第二组 COM引脚排布：010 待写入74HC595中的数据：LED_NUM2

第三组 COM引脚排布：001 待写入74HC595中的数据：LED_NUM3

然后对于每一个单独LED的控制，就需要用到逻辑运算，例如图中的LED1，其属于第三组LED，因为其控制COM引脚为COM3，

因而代码可以写为：

//只点亮LED1，而不影响本组内其他LED的显示
LED_NUM3 = LED_NUM3 | 0x01;
//只熄灭LED1，而不影响本组内其他LED的显示
LED_NUM3 = LED_NUM3 & (~0x01);

其他的LED控制也是一样的道理；

可以提取出公式，如LED的编号为0~~7，分别接在74HC595的Q0~~Q1引脚上，设任意一引脚为n号引脚，则其控制代码为：

//只点亮LEDn，而不影响本组内其他LED的显示
LED_NUM = LED_NUM | (0x01 PF0
STCP -> PA12
DS  -> PB5
COM1->PA15
COM2->PB3
COM3->PB4
*/
/**
 * @brief 模拟SPI向74HC595芯片发送数据
 * @param SendVal 待发送八位数据
 * @return 无
 */
void HC595SendData(uint8_t SendVal)
{
    uint8_t i;
    for (i = 0; i  0)
    {
        LED_NUM1 = LED_NUM1 | 0x08;
    }
    else
    {
        LED_NUM1 = LED_NUM1 & (~0x08);
    }
    HC595SendData(LED_NUM1);
    HC595SendData(0x00);

    HAL_GPIO_WritePin(COM1_PIN_GPIO_Port, COM1_PIN_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(COM2_PIN_GPIO_Port, COM2_PIN_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(COM3_PIN_GPIO_Port, COM3_PIN_Pin, GPIO_PIN_RESET);
    if (LED_second_case > 1)
    {
        LED_NUM2 = LED_NUM2 | 0x08;
    }
    else
    {
        LED_NUM2 = LED_NUM2 & (~0x08);
    }
    HC595SendData(LED_NUM2);
    HAL_Delay(0);
    HC595SendData(0x00);
    HAL_GPIO_WritePin(COM1_PIN_GPIO_Port, COM1_PIN_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(COM2_PIN_GPIO_Port, COM2_PIN_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(COM3_PIN_GPIO_Port, COM3_PIN_Pin, GPIO_PIN_SET);
    if (LED_second_case > 2)
    {
        LED_NUM3 = LED_NUM3 | 0x08;
    }
    else
    {
        LED_NUM3 = LED_NUM3 & (~0x08);
    }
    if (LED_power)
    {
        LED_NUM3 = LED_NUM3 | 0x40;
    }
    else
    {
        LED_NUM3 = LED_NUM3 & (~0x40);
    }
    if (LED_smart == 1)
    {
        if (pwm_high > pwm_t)
        {
            LED_NUM3 = LED_NUM3 | (0x20);
        }
        else
        {
            LED_NUM3 = LED_NUM3 & (~0x20);
        }
    }

    if (pwm_temp % 100 == 0)
    {
        if (flag == 1)
        {
            pwm_t--;
            if (pwm_t == 0)
            {
                flag = !flag;
            }
        }
        else
        {
            pwm_t++;
            if (pwm_t == 10)
            {
                flag = !flag;
            }
        }
    }
    pwm_high++;
    if (pwm_high == 10)
    {
        pwm_high = 0;
    }
    switch (LED_first_case)
    {
    case 1:
        /* code */
        LED_NUM3 = LED_NUM3 | (0x01);
        LED_NUM3 = LED_NUM3 & (~0x02);
        LED_NUM3 = LED_NUM3 & (~0x10);
        LED_NUM3 = LED_NUM3 & (~0x04);
        break;
    case 2:
        /* code */
        LED_NUM3 = LED_NUM3 & (~0x01);
        LED_NUM3 = LED_NUM3 | (0x02);
        LED_NUM3 = LED_NUM3 & (~0x10);
        LED_NUM3 = LED_NUM3 & (~0x04);
        break;
    case 3:
        /* code */
        LED_NUM3 = LED_NUM3 & (~0x01);
        LED_NUM3 = LED_NUM3 & (~0x02);
        LED_NUM3 = LED_NUM3 | (0x10);
        LED_NUM3 = LED_NUM3 & (~0x04);
        break;
    case 4:
        /* code */
        LED_NUM3 = LED_NUM3 & (~0x01);
        LED_NUM3 = LED_NUM3 & (~0x02);
        LED_NUM3 = LED_NUM3 & (~0x10);
        LED_NUM3 = LED_NUM3 | (0x04);
        break;
    default:
        break;
    }
    HC595SendData(LED_NUM3);
    HAL_Delay(0);
    HC595SendData(0x00);
}

，

我的年终总结（2022）

Sun, 01 Jan 2023 01:20:38 +0000

对于我来说，2022年是极为重要的一年；

关于读研

关键词：迷茫

在去年这个时候，我还在考虑读研的事情，我记得自己大三上学期所有科目成绩出来的那一天，我拿计算器算了一遍又一遍，最后得到一个心凉的结果：即使我大三下学期的核心课程考试都是100分，我也够不到保研的名额；算出来这个结果之后，说真的是心凉了一截；

虽然自己之前也大概估计着保研比较悬（每次考试都是考前突击，怎么可能稳保研），但是当自己真的算出来保研无望的那一刻，心里还是失落的；失落归失落，自己总还是要做出一个选择：考研或者工作；当然初期我根本没考虑工作的事情，一是对读研确实还有向往，二是我认识的同学或者学长他们绝大多数的选择都是考研；算是迷茫也算是随大流吧，我就打算考研；当然那个时候还比较早，才是一二月份，寒假在家那些天带着失落，自己也没开始复习，在家还是搞一点东西，在咸鱼接一些单子，自己搞一点东西做，在家也算开心；

开学之后回到学校，就真要开始准备复习了，自己开始也没买什么纸质资料，网上找了些英语数学的考研课程就开始复习了，前些天倒也算努力，还制定了一个简单的复习时间表，英语看的刘晓燕老师的视频课程，数学是看的李永乐老师的视频教程和习题册；准备了一两个月吧，那些天上课时候偷偷复习，晚上也经常自己去中楼的自习室复习；复习这么久，有进展没有嘞，说实话，没什么进展，说是考研复习，自己心里没什么劲头，也只是看同学他们都开始复习，自己跟风罢了；

复习时候，感觉很难受，可能也是自从高中之后自己再也没有像这样坐在那一坐一整天地复习，学来学去，进到自己脑袋的东西也不知道有多少；那时候为了复习还拒绝了很多事情，跟老师说我要考研，推掉本来要我做的项目，跟学姐说我要考研，推掉介绍给我的外快，跟父母说我要考研，让他们安心不要经常给我打电话，看起来自己是为考研做足了准备，貌似我就是要认真复习准备考研了；

在刚回到学校不久，班助学长他们组织了一个考研就业动员大会，从这里也能看出考研和工作的人数比例，我记得讲考研经验的有三四个人，而讲工作经验的只有一个人（这位学长应该是拿了TP-LINK SP或者更高档次的Offer），我还用手机的记事本记了很多考研经验，以备我后边用；

那我是什么时候改变想法了呢，我想是那天听的一个讲座，是毕业工作几年的学长们开的讲座，中间也讲到了工作和读研的抉择，最打动我的是一句话：你应该考虑读研三年和工作三年哪一个对自己的帮助大，你不应该拿着你现在去跟读研三年之后的你比，而应该拿读研三年之后的你和工作三年之后的你比；听了之后对我触动很大，我说，那就去试试找工作吧；我想，几年后，我再回来看今天，会发现今天将是改变我一生的日子（现在一年后来看，的确是这样）；

有一句话，很符合我那天的想法： “当你老了，回顾一生，就会发觉：什么时候出国读书、什么时候决定做第一份职业、何时选定了对象而恋爱、什么时候结婚，其实都是命运的巨变。只是当时站在三岔路口，眼见风云千樯，你作出抉择的那一日，在日记上，相当沉闷和平凡，当时还以为是生命中普通的一天。”

然后就放弃了考研，不知道算不算半途而废，因为自己都还没有走到半途；自己的这个打算对自己将来发展是利是弊，现在还未可知也；

至此，我的考研结束。

关于工作

关键词：期待

工作的念头出现的比较晚，就是在上面提到的那个讲座之后，自己才开始考虑找工作的事情；

最先当然是写简历，简历花了挺多时间写，不过也不是一天搞完的，我采取的方法是一天进步一点点，也就是一天写一部分，从个人信息、项目经历、个人荣誉一直写到专业技能，然后又润色润色，搞了差不多一个多星期才输出一份我自己比较满意的简历；

然后就是找合适的公司投递简历，那个时候还比较早，很多公司的提前批都还没开始，所以就先准备投个实习练练手，说起来也没有投几个，我记得就投了海康威视和OPPO这两个公司的实习，OPPO那个是一直没什么什么进展，前几天去看才发现我连简历筛选都没过，可能是跟JD不太匹配吧；至于海康威视，倒是一步步都正常进行，简历筛选过了，然后HR打电话问了我的一些基本情况，然后是技术面和HR面，当然也都顺利通过了，最后我也在杭州海康威视实习了整两个月的时间，虽然最后因为实习时间不够的缘故未能参加最后的转正答辩，但是我还是很感谢我在海康的那段实习经历，第一次让我接触到了实际的工作内容；

有一个比较神奇的地方，就是我后来拿到的大疆Offer的面试甚至比海康面试还要早一些，当我海康一面的时候，我就已经完成了大疆三面的流程在等最后结果了；

大疆是我很早就接触到的公司，我在大二参加了RoboMaster比赛，而这个比赛就是大疆举办的，所以我与大疆还是有一些小缘分的；大疆提前批很早，我记得是4月25那天就开放投递简历了，大疆的提前批其实更准确的说法应该是“RM专属通道”，是为曾经参加过RM比赛的同学们开通的一个投递通道，我刚好参加过一年这个比赛，所以就顺理成章地投递了简历，后来我才知道我竟然还是投递专属通道的前一百位同学中的一个，还收到了大疆寄给我的一份礼物；

大疆的面试流程走的很快，基本一周一个进度，所以在面试海康的时候我就已经完成了大疆的面试流程，面试大疆的面试经验对后边我面试海康起到了非常大的帮助；具体的时间表可以看一下我之前写的面经；

当我拿到海康实习的Offer后，我就决定去了，毕竟大疆的最后面试结果还没有出来，自己还要为后面的秋招准备，想着是有个实习经验，后面找工作会好一些，所以就去了杭州实习，其实实习时候自己还是比较迷茫的，对于自己到底要找什么样的工作，需要做一些什么样的准备都不太清楚，刷题刷了一些，面试经验也看了不少，但是又怀疑自己的学历到底够不够，硕士那么多，自己一个末流985本科找工作能找到吗，天天也是很焦虑，害怕自己找不到什么好的工作，怀疑自己放弃读研去找工作是不是正确的选择；焦虑归焦虑，日子还是一天天的过，看看书，做一点任务，刷刷题目，天天吃的也不少，可能也是海康餐厅的伙食不错；

转折点就在七月份的一天，我接到了大疆HR小姐姐打来的Offer Call，也收到了邮件发来的录用意向书；

我当时就想：好哦，我的秋招结束了；

知道自己拿到大疆Offer的那一刻，自己明显不那么焦虑了，当然学东西也还在学，但是更偏向自己兴趣而不是那些八股文了，因为在我看来，大疆的确是我比较好的工作去向了，不论是我面试的感受还是平常了解到的，大疆确实是我很喜欢的一家公司；

工作找到了，在海康又待了一个月，实习也结束了，又回到了学校；虽然拿到了录用意向书，但是又听说很多公司会有毁意向书的情况存在，又开始焦虑了，然后自己大四上学期又基本没有什么课程任务，就自己开始一天天摆弄自己的小玩意还有等待着最后的正式Offer，然后就在十月底的一天等到了，这样秋招才是正式结束了，悬着的心放下了，自己的秋招之旅也是有了一个满意的结果；

我对工作这件事感觉很陌生，自己上了快20年的学，终于也要到了工作的时候了，有期待也有不安；

但是日子还是一天天的过下去，一眼望到头的生活我不喜欢；

我希望自己成长，能成为自己小时候梦想的工程师那样：无所不能。

关于未来

关键词：无所不能

我前几天看到了一段话，感觉挺有道理：

生活不可能像你想象得那么好，但也不会像你想象得那么糟。我觉得人的脆弱和坚强都超乎自己的想象。有时，我可能脆弱得一句话就泪流满面，有时，也发现自己咬着牙走了很长的路。 ——莫泊桑《一生》

越往前走越能发现自己的路变得清晰；回想自己刚上大学时候那迷茫的样子，再看自己现在关于未来的想法，路变得越来越清晰了；

沿着这条路走下去，我也能成为自己期望的那种人；

新的一年，我希望我的家人平安幸福；

新的一年，我希望自己能在梦想的路上越走越远；

我想，我会成为自己想成为的那个工程师，掌握很多技能，面对问题，自己总能想到办法；

我相信我会成为这样的人：聪明、乐观、幽默、不言放弃、坚信问题终会被解决；

常用网站

Fri, 30 Dec 2022 02:46:33 +0000

收罗一些常用的网站；

1、立创开源硬件平台

当自己做一些硬件电路时在该网站上找一些参考设计；

立创开源硬件平台

2、立创商城

用于查询芯片的数据手册，有时也在该商城购买一些元器件，比较保真，开发票也很快；

立创商城

3、古月居ROS

用于查看一些ROS相关的教程，依稀记得自己入门ROS就是学习的古月居的教程；

古月居ROS

4、学长的博客

学长的博客网站，我记得自己AD库就是用的学长放在博客上面的；

刘威学长的博客

5、阿里云域名管理控制台

自己博客网站的域名就是在阿里云购买的，续费也是通过该平台进行；

阿里云域名控制台

6、ROBOMASTER赛事报名系统(专属通道投递简历)

ROBOMASTER赛事报名系统

7、牛客

找工作时候经常用的，用来看一些面经；

牛客

8、湖南大学WebVPN系统门户

不需要运行VPN客户端即可；

湖南大学WebVPN系统门户

9、威伯斯云登录页面

VPN登录页面；

威伯斯云登录页面

10、书伴

很多关于Kindle的使用技巧;

书伴

11、在线思维导图

用于在线绘制思维导图，可以导出为图片，很方便；

在线思维导图

12、阮一峰的博客

比较有意思；

阮一峰的博客

13、Typora官方中文站

有一些软件使用技巧；

Typora官方中文站

14、阿里云资源站

有很多的纪录片和电影小说可以下载；

阿里云资源站

15、磁力天堂

聚合类网站；

磁力天堂

16、哇酷开发者社区

之前搞荔枝派的时候经常使用这个网站；

WhyCan Forum(哇酷开发者社区)

17、阿里云矢量图标网站

之前搞LVGL用了很多这个网站上的小图标；

阿里云矢量图标网站

ubuntu2004无法联网问题

Thu, 29 Dec 2022 02:48:57 +0000

最近Ubuntu2004虚拟机无法联网，而且这个问题很常见，就记录一下；

参考：VMware Ubuntu20.04无法联网的解决方法

一、安装环境及版本

宿主机 Windows 10 虚拟机软件版本 VMware Workstation 16 Pro ubuntu版本 Ubuntu 20.04

二、解决方法

1、虚拟机->设置->网络适配器：进行如下设置：

2、然后打开终端窗口，在终端窗口输入如下命令：

sudo service network-manager stop
sudo rm /var/lib/NetworkManager/NetworkManager.state
sudo service network-manager start

3、再运行ifconfig便可以发现网络已经恢复正常；

FOC基础源码分析

Mon, 21 Nov 2022 08:05:05 +0000

以基于STM32F103的FOC源码为例分析；

保存电机参数

采用宏定义开关来决定是否要进行参数校准；

//1 已校准
//0 未校准
#define IS_ALIGN 0

//参数数据结构体
struct ALIGN_DATA
{
    long direction;
    int pole;
    float zero_angle;
} DATA_ALIGN;

//根据宏定义判断是否要更新FLASH中存储的参数
#if IS_ALIGN
    Internal_ReadFlash(ALIGN_ANGLE_ADDR, (uint32_t *)&DATA_ALIGN, 3);//读取内部FLASH中的参数
    sensor_direction = DATA_ALIGN.direction;    //方向
    pole_pairs = DATA_ALIGN.pole;               //极对数
    zero_electric_angle = DATA_ALIGN.zero_angle;//零点角度
#else
    //
    //此处略去参数识别代码
    //
    DATA_ALIGN.direction = sensor_direction;    //方向
    DATA_ALIGN.pole = pole_pairs;               //极对数
    DATA_ALIGN.zero_angle = zero_electric_angle;//零点角度
    Internal_WriteFlash(ALIGN_ANGLE_ADDR, (uint32_t *)&DATA_ALIGN, 3);//将参数写入单片机内部FLASH中

通过UART通信控制电机

/**
 * @brief 简易串口命令接收，需在while循环里重复调用该函数
 * @return 无
 */
void commander_run(void)
{
    if ((USART_RX_STA & 0x8000) != 0)
    {
        switch (USART_RX_BUF[0])
        {
        case 'H':
            printf("Hello World!\r\n");
            break;
        case 'T': // T6.28
            target = atof((const char *)(USART_RX_BUF + 1));
            printf("RX=%.4f\r\n", target);
            break;
        case 'D': // D
            M1_Disable;
            printf("OK!\r\n");
            break;
        case 'E': // E
            M1_Enable;
            printf("OK!\r\n");
            break;
        }
        USART_RX_STA = 0;
    }
}

#define USART_REC_LEN 256
unsigned char USART_RX_BUF[USART_REC_LEN]; //接收缓冲，usart.h中定义长度
//接收状态
// bit15  接收完成标志
// bit14  接收到0x0D
// bit13~0  接收的字节数
unsigned short USART_RX_STA = 0; //接收状态标志
//发送的命令必须以"\r\n"作为结尾，以标志命令的结束
void USART1_IRQHandler(void) //串口1中断程序
{
    unsigned char Res;
    if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //
    {
        Res = USART_ReceiveData(USART1); //读取接收到的字节
        if ((USART_RX_STA & 0x8000) == 0) //接收未完成
        {
            if (USART_RX_STA & 0x4000) //接收到了0x0d
            {
                if (Res != 0x0a)
                {
                    USART_RX_STA = 0; //接收错误，重新开始
                }
                else
                {
                    USART_RX_STA |= 0x8000;                     //接收完成
                    USART_RX_BUF[USART_RX_STA & 0X3FFF] = '\0'; //最后一个字节放'0’，方便判断
                }
            }
            else //还没收到0x0D
            {
                if (Res == 0x0d)
                {
                    USART_RX_STA |= 0x4000;
                }
                else
                {
                    USART_RX_BUF[USART_RX_STA & 0X3FFF] = Res;
                    USART_RX_STA++;
                    if (USART_RX_STA > (USART_REC_LEN - 1))
                    {
                        USART_RX_STA = 0; //接收错误，重新开始
                    }
                }
            }
        }
    }
}

CSAPP笔记

Sat, 05 Nov 2022 11:43:47 +0000

CSAPP学习中所记录的笔记；

第七章链接

链接是将各种代码和数据片段收集并组合成为一个单一文件的过程，这个文件可被加载（复制）到内存中并执行。

链接可以执行于：编译时：也就是在源代码被翻译成机器代码时；加载时：也就是在程序被加载器加载到内存并执行时；运行时：也就是由应用程序来执行；在早期系统，链接是手动执行的；在现代系统，链接是由叫做链接器的程序自动执行的；

链接器使分离编译成为可能；

学习链接的必要性：

理解链接器将帮助你构造大型程序；
理解链接器将帮助你避免一些危险的编程错误（例如，在默认情况下，错误的定义多个全局变量的程序将通过链接器，而不产生任何警告信息）；
理解链接器将帮助你理解语言的作用域规则是如何实现的（全局变量和局部变量之间的区别？static属性的变量或者函数到底意味着什么）；
理解链接将帮助你理解其他重要的系统概念（比如加载和运行程序、虚拟内存、分页、内存映射等）；
理解链接将使你能够利用链接库；

7.1 编译器驱动程序

贯穿本章的示例程序：

main.c main函数初始化一个整数数组，然后调用sum函数对数组进行求和；

int sum(int *a, int n);
int array[2] = {1, 2};
int main()
{
    int val = sum(array, 2);
    return val;
}

sum.c

int sum(int *a, int n)
{
    int i, s=0;
    for(i=0;i 以上命令等同于以下命令：
> 首先运行预处理器，将main.c翻译成ASCII码的中间文件main.i：
> ```bash
> cpp main.c /tmp/main.i
> ```
> 接下来，驱动程序运行C编译器，将main.i翻译成一个ASCII汇编语言文件main.s：
> ```plaintext
> cc1 /temp/main.i -Og -o /tmp/main.s
> ```
> 然后，驱动程序运行汇编器，它将main.s翻译成一个可重定位目标文件main.o：
> ```bash
> as -o /temp/main.o /tmp/main.s
> ```
> 驱动程序经过相同的过程生成sum.o。
> 最后，运行链接器程序ld，将main.o和sum.o以及一些必要的目标文件组合起来，创建一个可执行目标文件prog：
> ```bash
> ld -o prog /tmp/main.o /tmp/sum.o
> ```

要运行可执行文件prog，使用以下命令：

```bash
./prog

shell调用操作系统中一个叫做加载器的函数，它将可执行文件prog中的代码和数据复制到内存，然后将控制转移到这个程序的开头；

DJI面经

Mon, 31 Oct 2022 12:21:08 +0000

DJI面试经验；

流程时间表：

事件日期

投递简历 4月25日

性格测评 4月27日

第一次面试 5月3日

第二次面试 5月13日

第三次面试 5月20日

电话OC 7月22日

收到录用意向书 7月22日

谈薪电话 10月27日

收到正式OFFER 10月27日

沟通三方信息 10月28日

性格测评：

这个测评的题量还是比较大的（有大概一百多道题），不过时间也是完全足够的，有大概两个小时；

题型全部都是选择题；主要内容为：一些简单的行测题、图形推理题、性格测试题、各种主观题，从难度来说都不是很难，不过听说测评会刷掉挺多的人，不过也没必要刻意去违心地回答这些问题，表现真实一些就可以，毕竟如果是跟自己价值观相差很大的公司，你进入后也不会很舒服；

答题过程中会需要开摄像头，如果自己电脑不带前置摄像头的话，可能需要自备一个；

答题过程中是可以使用草稿纸进行演算的，这个是没有任何问题的；

其他的问题就没有了，可能需要提前了解一些大疆的各种产品信息等等；

PS:因为我投递的是提前批，所以并没有笔试部分。

第一次面试：

面试前我很紧张，毕竟是第一次正式面试，甚至比后面的海康暑假实习面试还要早很多；

面试前我准备了很多很多，把自己做过的项目都总结了一下，从头到尾过了一遍，听说会问比较多RTOS相关的知识，所以又把RTOS相关的知识过了一遍，即使这样，准备的还算比较充分，毕竟自己实际也做过很多很多自己的项目，但还是非常紧张；

面试平台用的是腾讯会议，会提前发会议链接；

我很早就在面试间等着，第一场面试的面试官有三位，他们三个轮换着来提问，不过应该其中一位是面试的主导者；

上来就是自我介绍，我提前准备了一个三分钟自我介绍，阿巴阿巴介绍完，面试官就开始问问题；例如你最满意的项目是什么，为什么会很满意，做项目遇到了什么问题，你是怎样解决的等等诸如此类的问题；

出乎我意料的是，整个面试中并没有问到什么知识点，唯一问到的就是单片机是如何启动到main函数的，而这个我正好复习过，就顺利地答上来了，面试官问和我回答的这段时间有二十分钟左右，后续就是问我有什么问题要问吗，我就问了几个应届生培养方案之类的问题；

总的来说，面试过程很愉快，也并没有自己相信的那样紧张；

大概是第二天，就收到了面试通过的邮件，效率很高；

第二次面试：

第一次面试之后过了大概一个星期就是第二次面试，这次面试只有一位面试官；

面试的内容跟第一次面试的内容很相似，也都是自我介绍，问自己做过的项目，最满意的项目是哪个，我就说是曾经做过的小一，然后问为什么会觉得满意，就围绕着这个项目谈了很多（主要可能是我自发的做的这个项目，并没有什么功利性），还问了你有没有跟市面上类似的产品做过比较等等的，你用的这个框架LVGL你觉得有什么不足之处吗；

后面还问了一些其他的问题，比如你FreeRTOS用的熟吗，队里边是只有你一个人用得熟，还是大家用的都很熟，平常在实验室都待到几点，在队伍里的感受怎么样，曾经有没有用过大疆的产品，这个产品你觉得有什么优点（我提到了大疆的一款无人机）；

面试官说话让人感觉到很舒服，很愉快，也不会让自己太紧张，这次的面试时间很长，大概有五十多分钟；

大概当晚我就收到了面试通过的消息；

第三次面试：

大概第二次面试通过五六天之后就是第三次面试，这次面试的面试官也是一位；第三次面试跟前两次有些不同，更多的是问我性格相关的问题，对项目相关的问题会少一些；

问的问题有：你用一个词语形容一下自己，这个我当时真的蒙了，就尝试说了几下自己的优势，然后面试官还追问说，那你用一个词语描述下呢？最后好像也没说出什么（还是怪我没有准备完全）；

还有就是问我有没有跟别人争执过，因为什么而争执，怎么解决的；你觉得你的性格方面有没有什么缺陷等等；

这场面试感觉答得不是很好，因为有些问题自己之前都没准备到，本以为凉凉了，没想到很快就通过了，然后就是等着综合评估结果；

大概第二天，登录招聘网站，就发现三面通过了，不过听说还会有综合排序，会刷一部分的人；

在七月下旬，终于接到OC（Offer Call）了，我的秋招正式结束；

AG1280串口通信

Sun, 30 Oct 2022 04:58:47 +0000

因为上次做的板子是将FPGA和一块MCU芯片集成在一块的，他们之间就需要通信，当然最容易实现的就是UART串口通信；下面的代码是一个Demo代码，实现的功能是，RX接收到什么，TX就发送相同的数据； FPGA芯片 AG1280Q48 时钟频率 48MHZ 波特率 921600 RX引脚 PIN_16 TX引脚 PIN_14 LED引脚 PIN_48 时钟输入引脚 PIN_15 复位引脚 PIN_17

具体代码如下：

顶层模块

module connect_mcu (input clk,
                    input rst_n,
                    input wire uart_rx,
                    output wire uart_tx,
                    output wire led);

    wire clk_pll_o; //PLL时钟

    inpll pll_inst (
    .clkin(clk),		// PLL.clkin MUST connect to PIN_XX_GB
    .clkfb(clk_pll_o),
    .pllen(1'b1),
    .resetn(rst_n),
    .clkout0en(1'b1),
    .clkout1en(1'b0),
    .clkout2en(1'b0),
    .clkout3en(1'b0),
    .clkout0(clk_pll_o),
    .clkout1(),
    .clkout2(),
    .clkout3(),
    .lock()
    );

    parameter  SYSTERM_CLK = 26'd48_000_000;               //系统时钟频率
    parameter  UART_BPS    = 20'd921600;                   //串口波特率

    wire       flag;
    wire [7:0] data;
    // assign led = data[0];

    uart_receive
    #(
    .SYSTERM_CLK   (SYSTERM_CLK),
    .UART_BPS      (UART_BPS)
    )

    u_uart_receive(
    .clk          (clk_pll_o),
    .rst_n        (rst_n),
    .uart_rx      (uart_rx),
    .receive_done (flag),
    .uart_data    (data)
    );

    uart_send
    #(
    .SYSTERM_CLK   (SYSTERM_CLK),
    .UART_BPS      (UART_BPS)
    )

    u_uart_send(
    .clk          (clk_pll_o),
    .rst_n        (rst_n),
    .uart_in_data (data),
    .uart_in_flag (flag),
    .uart_tx      (uart_tx)
    );

    reg [1:0] led_counter;
    assign led = led_counter[0];

    // parameter SEC_TIME = 32'd48_000_000;//48M
    reg	[31:0] cnt;

    always @ (posedge clk_pll_o or negedge rst_n)begin
        if (rst_n == 0)
            cnt = 4'd1)) begin
            reg_data

![f1992c7fce5ccbde038bca329048345](img-1.png)

AT32F403A系列单片机开发

Wed, 12 Oct 2022 15:07:03 +0000

记录AT32开发中遇到的问题；

硬件部分：

硬件部分我是参考官方开发板来做的；

经过测试，硬件部分没有任何问题；

原理图

PCB仿真图

实物图

显示效果

有几个值得关注的地方，我将在下面列出：

使用编码器开关作为输入设备；

使用CH340E芯片作为串口转USB；

通过TYPE-C接口的正反插实现不同的功能（连接CH340E芯片和AT32的USB引脚）：

屏幕接口采用的是FPC0.5mm接口，方便安装；

硬件部分的测试很快就结束了，主要就是测试各个外设是否能正常使用；

经测试，主控芯片、屏幕、spiflash、USB接口、CH340E、编码器开关、RTC时钟均能正常使用；

软件开发：

参考资料：

主控芯片使用的是雅特力的AT32F403ACGU7，其特性如下所示：

参考资料网站：https://www.arterytek.com/cn/product/AT32F403A.jsp

下载固件库源码，经解压后，可以在目录:

.\AT32F403A_407_Firmware_Library_V2.1.2\project\at_start_f403a\examples

找到各个外设的例子：

$ ls
acc/        crm/    gpio/  spi/         wwdt/
adc/        dac/    i2c/   sram/        xmc/
bpr/        debug/  i2s/   tmr/
can/        dma/    pwc/   usart/
cortex_m4/  exint/  rtc/   usb_device/
crc/        flash/  sdio/  wdt/

首先当然是串口打印和点灯，这样能测试时钟配置是否正常，以及判断芯片好坏与否；

具体开发：

关键代码如下：

点灯：

void at32_led_init(void)
{
    gpio_init_type gpio_init_struct;

    /* enable the led clock */
    crm_periph_clock_enable(USER_LED_GPIO_CRM_CLK, TRUE);

    /* set default parameter */
    gpio_default_para_init(&gpio_init_struct);

    /* configure the led gpio */
    gpio_init_struct.gpio_pins = USER_LED_PIN;
    gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
    gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
    gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;

    gpio_init(USER_LED_GPIO, &gpio_init_struct);
}

void at32_led_on(void)
{
    USER_LED_GPIO->clr = USER_LED_PIN;
}

void at32_led_off(void)
{
    USER_LED_GPIO->scr = USER_LED_PIN;
}

void at32_led_toggle(void)
{
    USER_LED_GPIO->odt ^= USER_LED_PIN;
}

串口：

void uart_print_init(uint32_t baudrate)
{
    gpio_init_type gpio_init_struct;

    /* enable the uart and gpio clock */
    crm_periph_clock_enable(PRINT_UART_CRM_CLK, TRUE);
    crm_periph_clock_enable(PRINT_UART_TX_GPIO_CRM_CLK, TRUE);
    gpio_default_para_init(&gpio_init_struct);

    /* configure the uart tx pin */
    gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    gpio_init_struct.gpio_mode = GPIO_MODE_MUX;
    gpio_init_struct.gpio_pins = PRINT_UART_TX_PIN;
    gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
    gpio_init(PRINT_UART_TX_GPIO, &gpio_init_struct);

    /* configure uart param */
    usart_init(PRINT_UART, baudrate, USART_DATA_8BITS, USART_STOP_1_BIT);
    usart_transmitter_enable(PRINT_UART, TRUE);
    usart_enable(PRINT_UART, TRUE);
}

串口重定向：

LCD底板设计

Wed, 12 Oct 2022 11:41:43 +0000

打算做一个适配1.33寸屏幕和2.0寸屏幕的底板，屏幕接口留出来两种，FPC排线连接，八位并行接口和SPI接口；

这个可能要搁置一段时间了，因为目前只做了集成MCU和屏幕的板子；

Typora修改高亮颜色

Wed, 12 Oct 2022 05:52:59 +0000

如何修改 Typora 「高亮」的颜色；

Typora 有一个「高亮」的格式（示例：==例子==），类似于荧光笔，但是感觉默认的颜色偏亮，看久了不舒服，所以利用修改主题文件的方式来自定义颜色。

操作很简单，先找到主题文件：「文件」 ==> 「偏好设置」（或者直接 Ctrl + 逗号），在右边「外观」栏中找到「打开主题文件」打开：

打开主题对应的 .css 文件，在最后面加上下面的文字：

mark {
  background: #a9d18e;
  border-bottom: 0px solid #ffffff;
  padding: 0.0px;
  margin: 0 0px;
}

如果只是想要单纯改变颜色，也可以只写 background的这一行：

mark {
    background: #a9d18e;
}

其中 backgraoud后面的十六进制数为所需要的颜色。border-bottom 是下划线的大小和颜色。padding就是上下左右的边框大小。margin就是所标记文字离左右文字的距离。

最后，Typora 中「高亮」没有快捷键，但是可以自定义。Ctrl+逗号打开「偏好设置」，在「通用」里最下面打开高级设置，找到下图位置，添加自己需要的快捷键：

// Custom key binding, which will override the default ones.
"keyBinding": {
  // for example:
  // "Always on Top": "Ctrl+Shift+P"
},

修改为：

// Custom key binding, which will override the default ones.
"keyBinding": {
  // for example:
  // "Always on Top": "Ctrl+Shift+P"
    "Highlight":"Ctrl+Shift+H"
},

最后的效果如下：

AG1280开发记录

Wed, 12 Oct 2022 04:51:04 +0000

AG1280是一款国产的CPLD芯片，我准备将这个芯片和MCU配合起来，来做一些定制化的接口和功能，例如扩展UART接口，外接一些高速的AD/DA芯片；

芯片资源：

AG1280资源：

LUTs 1280

Distributed RAM (Kbits) 10

EBR SRAM (Kbits) 68

Maximum User I/O pins 40

Number of PLLs 1

Package 48-Pin QFN

价格很便宜，每颗单价大概是7元；

我画了一个评估板，除了这颗CPLD芯片外，还加了一颗STM32F103C6T6芯片，他们之间有六个IO口互相连接来进行通信或者时钟输入；

STM32F103C6T6资源：

封装 / 箱体 LQFP-48

核心 ARM Cortex M3

程序存储器大小 32 kB

数据总线宽度 32 bit

ADC分辨率 12 bit

最大时钟频率 72 MHz

输入/输出端数量 48 I/O

数据 RAM 大小 10 kB

评估板设计：

板子原理图如下：

PCB视图如下：

硬件设计注意：

AG1280硬件设计中有几个需要特别注意的点：

1、IO_GLOBE_S1(位于第9脚)、IO_GLOBE_S2(位于第13脚)、IO_GLOBE_S3(位于第15脚)、IO_GLOBE_S4(位于第19脚)、IO_GLOBE_N1(位于第41脚) 、IO_GLOBE_N2(位于第44脚) 、IO_GLOBE_N3(位于第46脚)可以作为全局时钟输入管脚，可用于输入全局时钟。但若要使用PLL，则只能从13、15和19管脚输入。

2、电路板载一个24MHz有源晶振，另外还可以通过PMOD接口从STM32的MCO时钟输出管脚获得时钟，它们被连接到具有PLL输入功能的管脚13、15上。

3、AG1280的GPIO分为North和South两组，可以使用不同IO电平，以实现不同电平逻辑的转换。另外AG1280还需要3.3V电源作为片上Flash电源，且该电源域North组的IO电源共用，因此North组也只能使用3.3V的IO电源电压。South组却可以任选电源电压。

4、AG1280还需要1.2V内核电源电压，且该电源应略迟于Flash电源上电，以方便Flash加载程序。我的图2电路通过PMOD接口从STM32开发板获得3.3V电源，再用LDO芯片XC6206P122MR从3.3V向下稳压到1.2V内核电源，LDO后带有100uF电容,1.2V上电时间自然要落后于3.3V上电。

板子已经发出去打样了，估计今天就能到，我到时候焊接测试下；

软件：

环境配置：

AG1280的开发EDA软件Supera还不具备分析和综合电路的能力，但能实现其特有的PLL和片上RAM的IP核打包、综合后的布局布线、下载文件打包及下载等功能。

F1C100S驱动开发

Sun, 02 Oct 2022 04:23:19 +0000

Uboot和系统跑起来了，接下来就是进行驱动开发了；

Heartbeat(心跳灯)

修改设备树：

在设备树文件arch/arm/boot/dts/sun8i-v3s-licheepi-zero.dts中；

在 / { } 所包裹的根节点目录下添加：

leds {
    compatible = "gpio-leds";
    user_led {
    label = "led:usr";
        gpios = ; /* PE12 */
    };
};

其中

gpios = ; /* PE12 */

代表引脚 4 * 32 + 12也就是PE12（ A~G： 0~6） 其名字为：led:usr；

系统启动后与LED控制有关的文件；

系统启动后，将看到这样的文件：

$: ls /sys/class/leds/
led:usr

这里三个文件夹分别对应设备树中定义的三个LED；

编译设备树：

可以只编译设备树，不编译其他文件；

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- dtbs -j12

控制LED灯亮灭：

点亮LED：

$: echo 1 > /sys/class/leds/led\:usr/brightness

熄灭LED：

$: echo 0 > /sys/class/leds/led\:usr/brightness

控制LED闪烁：

F1C100S开发记录

Sat, 01 Oct 2022 04:10:08 +0000

最近画了一个Linux板子，主控是全志的F1C100S，自带了32M RAM，不是很大，但是可以学习下；

板子图片：

板子正面板子反面 UBoot启动

FLASH下载工具使用

1、通过命令 sudo sunxi-fel ver 来确认有无成功进入fel模式；

sudo sunxi-fel ver

2、短接FLASH1和4脚，可以进入fel模式，其实就是CS引脚拉低；

3、单次运行（下载到RAM中）：

sunxi-fel uboot /your/path/to/u-boot-sunxi-with-spl.bin

4、烧进 spi-flash （开机自启）

sunxi-fel -p spiflash-write 0 /your/path/to/u-boot-sunxi-with-spl.bin

其中0是烧录偏移地址；

Uboot编译

sudo apt-get install git
git clone https://gitee.com/LicheePiNano/u-boot.git
cd u-boot
# 查看分支
git branch -a
# 切换到 Nano 分支
git checkout nano-lcd800480

git clone -b nano-lcd800480 --depth=1 https://github.com/Lichee-Pi/u-boot.git
此处告知make采用arm-linux-gnueabi下的所有交叉编译工具，目标架构为Arm，设定各项默认配置为 nano 的spiflash支持版
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- f1c100s_nano_uboot_defconfig

# 若不带spi-flash的板子，请换成 licheepi_nano_defconfig

# 进行可视化配置
make ARCH=arm menuconfig

# 修改默认bootcmd
gedit include/configs/suniv.h
# 需要修改为
#define CONFIG_BOOTCOMMAND "run distro_bootcmd"

# 开始编译
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j8

只需要u-boot-sunxi-with-spl.bin即可；

FOC项目记录

Thu, 29 Sep 2022 03:35:34 +0000

大四应该没多少事情了，想继续做一下FOC相关的；

开发过程(持续更新)：

2022年9月29日：

中间好久没有更新，是这几天比较忙，没有时间写；

算下来，FOC的板子做了三个大的版本，五个比较小的版本，可以说是一次次的迭代更新；

主控供电方案驱动模块是否有电流采样通信方式

FOC-V1 STM32F103C6T6 AMS1117-3.3V DRV8313 否 UART

FOC-V2 STM32F103C6T6 AMS1117-3.3V DRV8313 否 UART

FOC-V3 STM32F103C6T6 AMS1117-3.3V MP6540 是 UART

FOC-V4 AT32F403ACGU7 AMS1117-5V & AMS117-3.3V DRV8313 否 UART

FOC-V5 STM32F405RGT6 L7805 & AMS1117-3.3V BTN7960B 是 UART/CAN

代码自己也加入了很多功能，电流环还没有做出来，后边再继续努力做，加油！

板子PCB：

版本图片

FOC-V1

FOC-V2

FOC-V3

FOC-V4

FOC-V5

2022年9月12日：

中间好久不更新，这些天对FOC项目做了更多的测试，还有做了一些应用，例如倒立摆，平衡车等等；

想要加上电流环，刚开始自然的想法是，用合金采样电阻加电流放大器加stm32的AD，这个外围电路比较麻烦，成本也很高；

昨天查找资料发现了一个芯片：MP6540，三相电机驱动芯片，且内部集成了电流检测，只需要用32的AD去读就可以了，今上午画了一个测试板，已经发去打样了，希望能正常工作；

等板子回来了，我测试一下，在说要不要改用这个芯片；

2022年9月3日：

修改的板子今天已经到了，焊接好了，也测试了，很完美，发热没那么严重了；

这次使用的LDO是AMS1117(SOT-89封装)，它的输入最高电压是18V，完全够用了，发热虽然还是很大，但封装也更大了，所以还是可以接受的；

AMS1117数据手册说明的的输入电压限制

在测试过程中，长时间运转未出现任何问题，闭环控制，开环控制都可以很好运转；

后续就是开始做平衡车，调参数；

2022年8月22日：

今天又查看了一下RT9013-33GB的数据手册，发现电压最大为5.5V，看来是要换供电部分的电路了；

输入电压限制输出电流限制

git常用命令

Wed, 28 Sep 2022 13:12:41 +0000

最近在做FOC项目的时候，用到了GIT中的分支功能，因而再复习一下GIT的用法，在此记录一下GIT常用命令；

为表简洁，我就直接给出具体的命令以及简短的注释和自己对此的理解；

1、git init

用于初始化git仓库；

2、git add +文件名

将指定工作区文件提交到git暂存区； -A，是添加文件夹内的所有文件到暂存区；每次提交，都要git add加入到暂存区，然后再commit提交；第一次修改 -> git add -> 第二次修改 -> git add -> git commit； commit提交的是git add 加入的修改的内容，而不是文件当前的内容；

3、git commit -m +“本次提交的说明”

将暂存区文件提交到仓库； -m，后边是关于本次提交的说明；该命令执行成功后会显示提交的内容：例如： 1 file changed：1个文件被改动； 2 insertions：插入了两行内容；

4、git status

显示当前仓库的状态（被修改的文件是否被提交）；例如某个文件被修改却未被提交；包括工作区的文件修改情况和暂存区的文件修改情况；

5、git diff +文件名

查看文件修改内容；常看尚未被提交的文件做了什么修改； 是工作区和暂存区文件之间的差别；

6、git log

显示从近到远的提交日志；

7、git reset —hard HEAD^

回退到上一版本； HEAD 当前版本 HEAD^ 上一版本 HEAD^^ 上上一版本

8、git reset —hard 1094a

回退或者前进到指定版本； —hard，后边的是版本号前几位；

UART中的硬件流控CTS和RTS

Wed, 14 Sep 2022 07:01:32 +0000

昨天花了一个USB转TTL小板子，其中芯片引脚有RT和CTS，之前从没用过，还是查找资料了解一下吧。

RTS （Require ToSend，发送请求）为输出信号，用于指示本设备准备好可接收数据，低电平有效，低电平说明本设备可以接收数据。

CTS （Clear ToSend，发送允许）为输入信号，用于判断是否可以向对方发送数据，低电平有效，低电平说明本设备可以向对方发送数据。

markdown编辑数学公式

Tue, 16 Aug 2022 08:41:33 +0000

用Markdown编辑数学公式看起来会很舒服，学一下；

希腊字母：

常见希腊字母：

$\alpha$、$\beta$、$\chi$、$\Delta$、$\Gamma$、$\Theta$
$$
\alpha\beta\chi
$$

显示效果为：

\alpha\beta\chi\Delta\Gamma\Theta

注：当希腊字母的LaTex语法首字母大写时，即输出大写的希腊字母；首字母小写时，输出小写的希腊字母。

数学结构：

分数：

$\frac{abc}{xyz}$

显示效果为：

\frac{abc}{xyz}

根号：

$$
\frac{\sqrt{1+abc}}{\sqrt{1-abc}}
$$

显示效果为：

\frac{\sqrt{1+abc}}{\sqrt{1-abc}}

向量符号：

$\overrightarrow{F}$

显示效果为：

\overrightarrow{F}

定界符：

$|$、$\|$、$\Uparrow$

显示效果为：

|、|、\Uparrow

注：将上述定界符与\left和right组合使用可以使得定界符匹配其内容的高度。

比如要构建一个如下的矩阵的行列式。

$$
\left|\begin{matrix}
   1 & 2 & 3 \\
   4 & 5 & 6 \\
   7 & 8 & 9
  \end{matrix} \right|
$$

显示效果如下：

\left|\begin{matrix} 1 & 2 & 3 \ 4 & 5 & 6 \ 7 & 8 & 9 \end{matrix} \right|

刷题中碰到的知识点

Mon, 08 Aug 2022 12:04:55 +0000

记录一下刷题中遇到的知识点；

1、(断言)assert

在程序设计中，断言（assertion）是一种放在程序中的一阶逻辑（如一个结果为真或是假的逻辑判断式），目的是为了标示与验证程序开发者预期的结果－当程序执行到断言的位置时，对应的断言应该为真。若断言不为真时，程序会中止执行，并给出错误消息。

XOR用法

Mon, 08 Aug 2022 09:08:09 +0000

异或的常见用法；

XOR用法

一、运算真值表：

0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0

二、运算定理：

一个值与自身的运算，总是为 false。

x ^ x = 0

一个值与 0 的运算，总是等于其本身。

x ^ 0 = x

可交换性

x ^ y = y ^ x

结合性

x ^ (y ^ z) = (x ^ y) ^ z

三、应用：

1、简化运算；

多个值的异或运算，可以根据运算定律进行简化。

a ^ b ^ c ^ a ^ b
= a ^ a ^ b ^ b ^ c
= 0 ^ 0 ^ c
= c

2、交换值；

两个变量连续进行三次异或运算，可以互相交换值。假设两个变量是x和y，各自的值是a和b。下面就是x和y进行三次异或运算，注释部分是每次运算后两个变量的值。

x = x ^ y // (a ^ b, b)
y = x ^ y // (a ^ b, a ^ b ^ b) => (a ^ b, a)
x = x ^ y // (a ^ b ^ a, a) => (b, a)

这是两个变量交换值的最快方法，不需要任何额外的空间。

3、加密；

异或运算可以用于加密。第一步，明文（text）与密钥（key）进行异或运算，可以得到密文（cipherText）。

text ^ key = cipherText

第二步，密文与密钥再次进行异或运算，就可以还原成明文。

如何做到有用的学习

Sun, 07 Aug 2022 08:25:05 +0000

转自知乎，如何做到有用的学习；

问题描述：为什么我的成绩那么好，最终还是成了一个没用的人？

作者：东坡夜奔链接：https://www.zhihu.com/question/30375123/answer/48170636 来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

基本问题：

说两个问题。一是知识空白的问题。二是知识技能化的问题。

1、知识空白

我们初高中（甚至大学）学到的知识，是教育部根据我国整体教育情况，考虑成本和国家工业化的需求，制定的一整套学习计划。

说白了，目的很简单：就是用尽可能低的成本，培养出对于推进我国工业化和现代化足够多的人才。

对于每个人个人的具体情况，对于一个人的人格情感培养，对于毕业后在社会上的就业，对于一个人的自我实现，基本上都没有考虑。

它是一个整体考量，不是个体考量。

所以，你会有很多知识空白。

很多对于你自己人生成长成才所必须的知识，是空白的，尤其对于出身小地方或者农村的孩子们，学校教育几乎是唯一接受教育的途径，这种情况就更加严重。

情感教育，心理教育，人格教育，美学，人际交往知识，良好的生活习惯……

都没有，都是空白。

再加上城市与农村的差异带来的冲击，学校和社会的差异带来的冲击，面临这样的心理困境，是正常的，不必过于焦虑。——这些东西，我们的教育中也是空白。

这些重要的东西，经济发达物质基础好，父母见识广的地方，可能可以通过家庭教育进行弥补（他们的问题本来就少），但鉴于目前的经济和教育水平，在我国绝大多数地区，都做不到。

我大学之后陷入困境，某种程度上，就是因为这些缺失的知识。

比如心理学，比如思维科学，最重要的两门课，如何保持心理康健，如何正确地进行思考，我们的学校教育中都是空白。

随着经济的不断发展，随着整个社会对于个体的逐渐重视，这个情况会有所好转，但是，我们毕竟来不及了。

所以延伸出来的，就是自我教育的问题。

好在你还年轻，会读书，会工作，会上网，会来知乎学习，会自我教育，就不算晚。

2013年11月3日，我在某笔记里写下一篇名为《五年多的成长》的日记，里面写到毕业后才意识到的，自己所面临的困惑。

六种困惑，其实都是知识的空白而已。

1、男女之惑——对于情感的知识

2、心理之惑——心理学

3、性格之惑——我是什么性格以及为什么是这个性格

4、方法之惑——为什么一腔真心、无数努力却做不成事

5、自我之惑——我是不是没有自我，为什么没有自我，如何建立自我

6、方向之惑——未来要怎么走

其实这些问题，通过心理学和思维科学的学习，在毕业之后的五年里，我基本都有了较为清晰的阶段性认识。

问题是，在之前的22年里，我不知道这些知识。

自我教育，毕业之后的自我教育，才是人生成长的关键。

这是对知识空白问题的解决。

2、知识技能化

我们学校中学习的，都是知识，但对于个人来说，知识不转化为技能，就无用。

知识当然是伟大的，那是人类百万年进化的结晶，但是，我们必须意识到，你的知识只有转化为技能，才拥有了价值。

你的价值，附着于你的技能之上。

你是律师，你要会打官司，能打赢官司，才能赚到钱，体现个人价值。

你是医生，你要会治病，能治好病，才能赚到工资，体现个人价值。

你是警察，你要会维持治安，打击犯罪，才能赚到工资，体现个人价值。

……

你说我有知识，但是我什么都不干，那就只好饿死，因为你没有通过技能体现出你的价值来。

当年明月研究了多年明史，如果他不写出《明朝那些事儿》，就无法证明自己的价值。——他把明史的知识技能化了——转变成了一本书。

郎朗学习了多年钢琴，如果他不去参加比赛获奖不去表演，就无法证明自己的价值。——他把钢琴弹奏技能化了——转变为一首首曲子。

你要把你学习到的知识转化为对这个社会有价值的技能，这才有用。

还是自己的例子，经过三年的锻炼，我基本上掌握了公文写作的技能，所以现在很崩溃，写稿子写讲话稿写的脑子想炸了，但是我的知识（文字知识，政治知识，写作知识，专业知识，部门知识……）转化为了技能（公文写作）。

所以，你就可以靠技能吃饭了，有了这个技能，虽然并不是多大的笔杆子，但毕竟有了自己的利用价值，所以领导对自己还不错，提拔的时候也会考虑，不至于让你做凉板凳坐很久。

家有万贯不如一技傍身，就是这个意思。

你学了那么多知识，可否能够转化为某种对这个社会、对别人有价值的技能？

技能远大于知识。

技能能吃饭，知识不行。

技能能发家，知识不行。

切记切记，要将知识转化为技能。

比如：你看了那么多电影，一肚子电影的知识，可有没有想过写剧本？

写剧本，就是技能。

另：会考试也是一个技能啊，而且是很厉害的技能，一次没考上怕什么，多考几次就是了。

延伸问题：

技能的门槛。

你说我有技能啊，为什么还是没价值？

可能是你自己的技能没有建立高门槛，随便就被别人比下去了。

这是个高度竞争的社会。

二八法则。

所谓20%的人赚走80%的利润，就是因为人家建立了高门槛。

1、高门槛不一定需要知识，人家资本雄厚，同样是高门槛，人家脸皮够厚，同样是高门槛，知识只是一个参考因素。

2、在知识—技能这个维度，建立高门槛需要精确定位市场、研究规律、不断实践、积累经验、建立细节体系——建立你自己的高门槛，就能享受相对高的回报，因为你的价值也是相对高的。——这需要时间，需要思考，需要不断改进、需要耐心。

3、耐心本身就是一个高门槛，这个世界上，聪明人很多，耐心的人，却真的不多。

4、知识很重要，要充分利用（别小看考试能力，你知道多少领导家孩子想要进公务员系统却考不进来吗？），尤其是当你只拥有知识的时候，但问题是，不要过于夸大知识的作用，而且，你所拥有的知识，并不一定有价值。

实习记录与总结

Sun, 07 Aug 2022 06:17:14 +0000

到今天为止（2022\08\07），我的暑假实习就要接近尾声了，我想，记录一下我这一个多月的实习经历吧，毕竟这是自己的第一份正式工作；

谷歌发现的十条真理

Sat, 06 Aug 2022 07:06:15 +0000

Google的网站上有一个网页，叫做“我们的哲学”（Our Philosophy），上面列出了十句话。

1. 用户第一，然后其他事情就会发生。

（Focus on the user and all else will follow.）

2. 最好的方法就是把一件事情做到非常、非常好。

（It’s best to do one thing really, really well.）

不要在乎自己现在的状况，如果你不断地正确地做一件事情，总有一天会有不一样的结果。

3. 快比慢好。

（Fast is better than slow.） “我们也许是世界上唯一一家希望用户尽快离开自己网站的公司：最快地给出用户想要的结果，一个多余的字节也没有，并且还在致力于变得更快。”

4. 民主在网上很管用。

（Democracy on the web works.）相信民主的人在互联网上能获得成功，相信管制和独裁的人在互联网上必将遭到失败。

5. 要寻找答案，不一定需要办公桌。

（You don’t need to be at your desk to need an answer.）

6. 不干坏事，也能挣到钱。

（You can make money without doing evil.）当考验来临时，要将信念置于金钱之上。坚信人生中有比金钱和物质更重要的东西，更加坚信这样做的人最终会赢得信赖和回报。

7. 未知的信息总是存在的。

（There’s always more information out there.）

计算机基础补全计划

Wed, 27 Jul 2022 14:02:56 +0000

自己虽然是写程序的，但是专业是自动化，毕竟不是计算机科班出身，还是要补一补计算机基础的；

计算机基础：

计算机组成原理； 《深入理解计算机原理》
操作系统； 《操作系统导论》
计算机网络； 《计算机网络：自顶向下方法》
数据结构与算法；
编译原理；

学习过程记录：

先学习计算机网络，正好视频跟课本是配套的：

参考B站视频，争取一个月内补全计算机网络相关的知识；

链接：https://www.bilibili.com/video/BV1JV411t7ow?spm_id_from=333.337.search-card.all.click&vd_source=d3e0d33e56175cb1e5a020e1a154d370

到今天为止，把计算机网络的内容过了一遍，满打满算花了一个月吧，后续肯定还需要更多的时间去消化这些知识内容；

后续看一下计算机系统整体相关的知识吧，大四这一年应该是难得的知识摄入的时间。

我会成为自己所期望的那个工程师吗

Sat, 23 Jul 2022 06:24:02 +0000

昨天收到了大疆的录用意向offer，很开心，从四月投递简历，到终面结束，再到昨天收到意向offer，自己花了很多的时间和精力去修改简历和准备面试，终于还是等到了；

关于DJI面试

收到意向offer的时候，我正在海康的三楼餐厅吃饭，看到是深圳的电话，我就猜到是大疆的HR打来的；

我很早就听说过大疆，那时候只是知道大疆是一家做无人机的公司，更多的就没有什么了解了；

大二开学，我报名参加了我们学校的RoboMaster战队，在队内总共呆了一年，主要是负责哨兵机器人的嵌入式开发；说来惭愧，我并没有为我们队伍做出过什么大的贡献，自己也没有做什么创新性的东西，充其量我的表现是中规中矩，大多数时候都是在补充自己的知识储备，不过正是通过这个比赛我才更近距离地接触到大疆，也认识了挺多学长学姐，这对我的影响很大；

在备赛过程中，我用过大疆的无刷电机，很强，功能很强，控制尤其方便，还勾起了我对无刷电机控制的兴趣，学了一点FOC，然后用开源的Simple FOC，做了一个简单的无刷电机驱动器，很有意思，在大疆的面试中，面试官问我：“你能不能说一个你用过的大疆的产品的一个缺点？”，我就提到了这件事，并说了一个我认为大疆的无刷电机所存在的缺点。

我只去过一次比赛现场，感受过那种赛场的氛围，很难忘的经历，在面试中，面试官问了我一个问题：

“你对大疆印象最深的是什么？” “我印象最深的就是是大疆的社会责任感，因为我去过比赛现场，所以我很感激大疆提供的这种难得的机会，对我这样的人来说，这是很难忘也很难得的机会；”

不知道面试官对我的回答是否满意，但这的确是我心里的想法；

我想，今天这个日子，几年或者更久的时间后，再回头来看，可能会说今天是一个十分重要的日子；

4月25日，我投出了我的简历；然后按部就班，面试面试还是面试，一共三轮面试，最后就是等offer；

在准备面试中，花了很多精力，学了好多东西，实时操作系统的知识还有C语言和ARM内核相关的知识，也把自己做过的项目，参加过的比赛都捋了好多遍，生怕面试官问到这方面的内容，自己却答不上来；

这是我第一次投简历和面试，之前听说找工作时永远不要将自己最想去的公司放在第一个，因为第一次总是没有经验，总会紧张。所以如果第一次就要投最想去的公司，那就要认真准备了；

准备面试的那几个星期我记了好多笔记，梳理了知识点，理通了自己做过的所有的项目还考虑了面试官可能问到的各种问题，记了几万字的笔记；

我还记得那个下午，我在自习室坐了一天，把FreeRTOS的相关知识从头到尾梳理了一遍；

准备的越多，自己就越有底气；

虽然面试中并没有问到很多自己准备的问题，但是准备的过程还是很大程度上减弱了自己的紧张；

虽然付出并不总是有收获的；

但是想到自己经常熬夜去解决一个又一个Bug，熬夜画一个又一个板子，自己乐在其中，享受做东西的快乐；

关于我的愿望

我QQ签名是：

立志成为一名嵌入式开发攻城狮！

是的，成为一名工程师是我一直以来的愿望；

前些天我又看了一遍《三傻大闹宝莱坞》，每次看的感觉都不一样；

第一次看这部电影是在我六年级的时候，那个时候觉得做一名工程师好酷，好像什么都能做出来，好像能解决遇到的一切问题，还有着不错的薪资；

现在想来，梦想成为一名工程师的想法就是从那个时候开始的吧；

兰彻，聪明，幽默，还有很多奇葩的想法，这部电影，让我觉得，做一名工程师会是多么有意思的事情呀；

能用自己的知识解决遇到的各种问题，而且乐在其中；

路一步步走，越走就离自己最初的想法越近；

最后我想说

我想，我会成为自己想成为的那个工程师，掌握很多技能，面对问题，自己总能想到办法；

我相信我会成为这样的人：聪明、乐观、幽默、不言放弃、坚信问题终会被解决；

正式OFFER（2022年10月31号更新）

上周五中午接到电话，谈了薪水，晚上收到了正式OFFER，然后沟通了三方，尘埃落定；

说真的，大疆开的是真的高，福利也不错，我是非常满意了，所以就决定去了。

下面整理一下整个流程，也许可以帮助到后面的人：

事件日期

投递简历 4月25日

性格测评 4月27日

第一次面试 5月3日

第二次面试 5月13日

第三次面试 5月20日

电话OC 7月22日

收到录用意向书 7月22日

谈薪电话 10月27日

收到正式OFFER 10月27日

沟通三方信息 10月28日

BIN、HEX、AXF和ELF的区别

Thu, 21 Jul 2022 06:00:53 +0000

几种常见格式的区别；

一、bin文件

Bin文件是最纯粹的二进制机器代码, 或者说是”顺序格式”。按照assembly code顺序翻译成binary machine code，内部没有地址标记。Bin是直接的内存映象表示，二进制文件大小即为文件所包含的数据的实际大小。

BIN文件就是直接的二进制文件，一般用编程器烧写时从地址0x00开始，而如果下载运行，则下载到编译时的地址即可。可以直接在裸机上运行。

二、hex文件

Intel hex 文件常用来保存单片机或其他处理器的目标程序代码。它保存物理程序存储区中的目标代码映象。一般的编程器都支持这种格式。就是机器代码的十六进制形式,并且是用一定文件格式的ASCII码来表示。

HEX文件由记录（RECORD）组成。在HEX文件里面，每一行代表一个记录。每条记录都由一个冒号“:”打头，其格式如下：

文件格式：

:BBAAAATTHHHH…HHHHCC　

含义分别如下：　

BB：字节个数； AAAA：数据记录的开始地址，高位在前，低位在后； TT: Type ；

Type： 00数据记录，用来记录数据；01记录结束，放在文件末尾，用来标识文件结束；02用来标识扩展段地址的记录；04扩展地址记录(表示32位地址的前缀)；

HHHH：一个字(Word)的数据记录,高字节在前,低字节在后；

TT之后共有 BB/2 个字的数据。

CC: 占据一个Byte的CheckSum；

举例：

每行中的数据并不是一定有的，第二个字节数据长度为0，那么这行就没有数据。

由于每行标识数据地址的只有2Byte，所以最大只能到64K，为了可以保存高地址的数据，就有了Extended Linear Address Record。如果这行的数据类型是0x04，那么，这行的数据就是随后数据的基地址。例如：

:020000040004F6 :1000000018F09FE518F09FE518F09FE518F09FE5C0 :1000100018F09FE5805F20B9F0FF1FE518F09FE51D :00000001FF

第一行，是Extended Linear Address Record，里面的数据，也就是基地址是0x0004；

第二行是Data Record，里面的地址值是0x0000。那么数据18F09FE518F09FE518F09FE518F09FE5要写入FLASH中的地址为 (0x0004 « 16) | 0x0000，也就是写入FLASH的0x40000这个地址。

同样，第三行的数据的写入地址为0x40010。当一个HEX文件的数据超过64k的时候，文件中就会出现多个Extended Linear Address Record。

校验值：每一行的最后一个值为此行数据的校验和。例如：

:1000000018F09FE518F09FE518F09FE518F09FE5C0 这行中的 0xC0； :1000100018F09FE5805F20B9F0FF1FE518F09FE51D 这行中的 0x1D；

校验和的算法为：计算从0x3A 以后（不包括0x3A）的所有各字节的和模256的余。即各字节二进制算术和，不计超过256的溢出值，然后用0x100减去这个算数累加和，得出得值就是此行得校验和。

如手头的STM32 HEX 第一行 020000040800F2；

End of File Record 行是每一个HEX文件的最后一行。例如：

力扣刷题记录

Sun, 17 Jul 2022 15:20:23 +0000

记录自己刷算法题中遇到的问题和自己的思路；

1、无重复长度的最长子串：

题目描述：

提示： 0 <= s.length <= 5 * 104； s` 由英文字母、数字、符号和空格组成；

思路：

就是做两个标志位，表示当前字符串的起始位置和正在比较的字符位置；

遍历整个字符串；

从起始标志位开始，到结束位置，依次比对是否有重复字符；

如果无，就结束位置加加；

如果有，就计算长度，并移动起始位置到重复字符的下一个位置；

然后一直循环；

要特别考虑：

au
abb
bba

这些特殊排序的字符串；

是因为最后一个没有办法比较；

题解代码：

int lengthOfLongestSubstring(char *s)
{
    int str_length = strlen(s);
    int end_flag = 1, start_flag = 0, max_length = 1;
    char flag = 0;
    int i = 0;
    if (str_length == 0)
    {
        return 0;
    }
    while (*(s + end_flag) != '\0')
    {
        for (i = start_flag; i  max_length)
                {
                    max_length = end_flag - start_flag;
                }
                flag = 1;
                break;
            }
            if (i == str_length - 2)
            {
                if ((*(s + end_flag + 1) == '\0'))
                {
                    if (end_flag - start_flag + 1 > max_length)
                    {
                        max_length = end_flag - start_flag + 1;
                    }
                }
            }
        }
        if (flag == 1)
        {
            flag = 0;
            start_flag = i + 1;
        }
        else
        {
            end_flag++;
        }
    }
    return max_length;

改进：

//方法2
int lengthOfLongestSubstring(char * s){
    int str_length=strlen(s);
    int end_flag=1,start_flag=0,max_length=1;
    char flag=0;
    int i=0;
    if(str_length==0)
    {
        return 0;
    }
    while(*(s+end_flag)!='\0')
    {
        for(i=start_flag;imax_length)
            {
                 max_length=end_flag-start_flag;
            }
            flag=0;
            start_flag=i+1;
        }
        else
        {
            if(end_flag-start_flag+1>max_length)
            {
                 max_length=end_flag-start_flag+1;
            }
            end_flag++;
        }
    }
    return max_length;
}

2、括号匹配

malloc和free的用法

Sat, 16 Jul 2022 06:48:25 +0000

在C语言中，内存管理是很重要的，最近刷算法题目也用到了malloc和free函数，在此记录一下；

一、函数原型及说明：

malloc()：

函数原型：

void *malloc(long NumBytes);

该函数分配了NumBytes个字节，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）。关于分配失败的原因，应该有多种，比如说空间不足就是一种。

free()：

函数原型：

void free(void *FirstByte);

该函数是将之前用malloc分配的空间还给程序或者是操作系统，也就是释放了这块内存，让它重新得到自由。

二、函数使用注意事项：

1、申请了内存空间后，必须检查是否分配成功；

2、当不需要再使用申请的内存时，记得释放；

释放后应该把指向这块内存的指针指向NULL，防止程序后面不小心使用了它。

3、这两个函数应该是配对使用；

如果申请后不释放就是内存泄露；如果无故释放那就是什么也没有做。释放只能一次，如果释放两次及两次以上会出现错误（释放空指针例外，释放空指针其实也等于啥也没做，所以释放空指针释放多少次都没有问题）。

**4、虽然malloc()函数的类型是(void )，任何类型的指针都可以转换成(void )，但是最好还是在前面进行强制类型转换，因为这样可以躲过一些编译器的检查；

三、具体例子：

// Code...
char *Ptr = NULL;
Ptr = (char *)malloc(100 * sizeof(char));
if (NULL == Ptr)
{
    exit (1);
}
gets(Ptr);
// code...
free(Ptr);
Ptr = NULL;
// code...

四、原理部分：

1、malloc内存空间的来源：

答案是从堆里面获得空间。也就是说函数返回的指针是指向堆里面的一块内存。操作系统中有一个记录空闲内存地址的链表。当操作系统收到程序的申请时，就会遍历该链表，然后就寻找第一个空间大于所申请空间的堆结点，然后就将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。

在使用malloc()分配内存空间后，一定要记得释放内存空间，否则就会出现内存泄漏。

2、free释放了什么：

free()释放的是指针指向的内存。注意！释放的是内存，不是指针！指针并没有被释放，指针仍然指向原来的存储空间。指针是一个变量，只有程序结束时才被销毁。释放了内存空间后，原来指向这块空间的指针还是存在！只不过现在指针指向的内容的垃圾，是未定义的，所以说是垃圾。因此，释放内存后把指针指向NULL，防止指针在后面不小心又被解引用了。 free() 不会改变指针变量本身的值，调用 free() 后它仍然会指向相同的内存空间，但是此时该内存已无效，不能被使用。所以建议将指针的值设置为 NULL，例如：
free(ptr);
ptr = NULL;

free()的源代码：

struct mem_control_block {
    int is_available;    //一般来说应该是一个可用空间的首地址，但这里英文单词却显示出空间是否可用的一个标记
    int size;            //这是实际空间的大小
};
void free(void *ptr)
{
    struct mem_control_block *free;
    free = ptr - sizeof(struct mem_control_block);
    free->is_available = 1;
    return;
}

五、直接定义一个数组和使用malloc动态分配的区别：

malloc作为一个包含在头文件下的函数，用于申请空间。

比较好的知识网站记录

Wed, 13 Jul 2022 14:52:14 +0000

一些比较好的网站的集锦；

1、阮一峰的网络日志：

Make 命令教程主要是关于Makefile的简单教程，看了之后基本能够完成一个比较完备的Makefile；
这是我自己总结的例子：Makefile基本示例；
跟我一起写Makefile教程：跟我一起写Makefile；
网站上还有不少比较好的教程和博客：网站首页；

2、Bash脚本教程：

阮一峰的Bash脚本教程；

3、C语言入门教程：

阮一峰的C语言入门教程；

GCC常见命令及用法

Sat, 09 Jul 2022 13:52:33 +0000

GCC工具介绍以及常见的用法；

GCC编译命令：

1. GCC工具

GCC编译器：

GCC（GNU Compiler Collection）是由 GNU 开发的编程语言编译器。 GCC最初代表“GNU C Compiler”，当时只支持C语言。后来又扩展能够支持更多编程语言，包括 C++、Fortran 和 Java 等。因此，GCC也被重新定义为“GNU Compiler Collection”，成为历史上最优秀的编译器，其执行效率与一般的编译器相比平均效率要高 20%~30%。

GCC的官网地址为：https://gcc.gnu.org/，在Ubuntu系统下系统默认已经安装好GCC编译器，可以通过如下命令查看Ubuntu系统中GCC编译器的版本及安装路径：

GCC编译工具链：

GCC编译工具链（toolchain），是指以GCC编译器为核心的一整套工具。它主要包含以下三部分内容：

gcc-core：即GCC编译器，用于完成预处理和编译过程，把C代码转换成汇编代码。
Binutils ：除GCC编译器外的一系列小工具包括了链接器ld，汇编器as、目标文件格式查看器readelf等。
glibc：包含了主要的 C语言标准函数库，C语言中常常使用的打印函数printf、malloc函数就在glibc 库中。

在很多场合下会直接用GCC编译器来指代整套GCC编译工具链。

Binutils工具集：

Binutils（bin utility），是GNU二进制工具集，通常跟GCC编译器一起打包安装到系统，它的官方说明网站地址为： https://www.gnu.org/software/binutils/ 。

在进行程序开发的时候通常不会直接调用这些工具，而是在使用GCC编译指令的时候由GCC编译器间接调用。下面是其中一些常用的工具：

as：汇编器，把汇编语言代码转换为机器码（目标文件）。
ld：链接器，把编译生成的多个目标文件组织成最终的可执行程序文件。
readelf：可用于查看目标文件或可执行程序文件的信息。
nm ：可用于查看目标文件中出现的符号。
objcopy：可用于目标文件格式转换，如.bin 转换成 .elf 、.elf 转换成 .bin等。
objdump：可用于查看目标文件的信息，最主要的作用是反汇编。
size：可用于查看目标文件不同部分的尺寸和总尺寸，例如代码段大小、数据段大小、使用的静态内存、总大小等。

系统默认的Binutils工具集位于/usr/bin目录下，可使用如下命令查看系统中存在的Binutils工具集：

# 在Ubantu上执行如下命令
ls /usr/bin/ | grep linux-gnu-

glibc库：

glibc库是GNU组织为GNU系统以及Linux系统编写的C语言标准库，因为绝大部分C程序都依赖该函数库，该文件甚至会直接影响到系统的正常运行，例如常用的文件操作函数read、write、open，打印函数printf、动态内存申请函数malloc等。

在Ubuntu系统下，libc.so.6是glibc的库文件，可直接执行该库文件查看版本，在主机上执行如下命令：

# 在Ubantu上执行如下命令
# 以下是Ubuntu 64位机的glibc库文件路径，可直接执行
/lib/x86_64-linux-gnu/libc.so.6

算数式计算

Fri, 08 Jul 2022 15:36:23 +0000

字符串算式先转为逆波兰式(后缀表达式)，然后计算；

一、求逆波兰表达式

核心思想：

逆波兰算法的核心思想是将普通的中缀表达式转换为后缀表达式。

**什么是中缀表达式？**例如a+b，运算符在两个操作数的中间。这是我们从小学开始学习数学就一直使用的表达式形式。 **什么是后缀表达式？**例如a b + ，运算符在两个操作数的后面。后缀表达式虽然看起来奇怪，不利于人阅读，但利于计算机处理。 转换为后缀表达式的好处是： 去除原来表达式中的括号，因为括号只指示运算顺序，不是实际参与计算的元素。使得运算顺序有规律可寻，计算机能编写出代码完成计算。

核心步骤：

逆波兰算法的核心步骤就2个：

将中缀表达式转换为后缀表达式，例如输入的原始表达式是 3*(5+7) ，转换得到 3 5 7 + * 根据后缀表达式，按照特定的计算规则得到最终计算结果

具体步骤：

中缀表达式转换为后缀表达式：

你需要设定一个栈SOP,和一个线性表 L 。SOP用于临时存储运算符和左括号分界符( ，L用于存储后缀表达式。
遍历原始表达式中的每一个表达式元素：如果是操作数，则直接追加到 L中。只有运算符或者分界符（才可以存放到栈SOP中；
如果是分界符：如果是左括号 ( ，则直接压入SOP，等待下一个最近的右括号与之配对。
如果是右括号 ) ，则说明有一对括号已经配对(在表达式输入无误的情况下)。不将它压栈，丢弃它，然后从SOP中出栈，得到元素e，将e依次追加到L里。一直循环，直到出栈元素e 是左括号 ( ，同样丢弃他。
如果是运算符（用op1表示）：如果SOP栈顶元素（用op2表示）不是运算符，则二者没有可比性，则直接将此运算符op1压栈。例如栈顶是左括号 ( ，或者栈为空。
如果SOP栈顶元素（用op2表示）是运算符，则比较op1和 op2的优先级。如果op1 > op2 ，则直接将此运算符op1压栈。
如果不满足op1 > op2，则将op2出栈，并追加到L，再试图将op1压栈，如果如果依然不满足 op1>新的栈顶op2，继续将新的op2弹出追加到L ，直到op1可以压入栈中为止。

简单Makefile

Thu, 07 Jul 2022 14:12:55 +0000

一个简单的Makefile，可以直接Copy使用；

一、用字符常量简化

Makefile文件：

#定义常量
objects =main.o fun1.o #中间文件
cc=gcc    #编译器
prom=main #输出文件

prom: $(objects)
		$(cc) $(objects) -o $(prom)
main.o: main.c fun1.h
		$(cc) -c main.c -o main.o
		@echo 正在编译main文件 #前面加@避免重复输出信息
fun1.o: fun1.c fun1.h
		$(cc) -c fun1.c -o fun1.o
		@echo 正在编译其他文件
.PHONY: clean
clean:
		-rm $(prom) $(objects)

文件夹结构：

二、更简化的写法

Makefile文件：

obj=main.o fun1.o
cc=gcc
prom=main
deps=fun1.h
$(prom):$(obj)
	$(cc) -o $(prom) $(obj)
%.o:%.c $(deps)
	$(cc) -c $< -o $@

在这里，我们用到了几个特殊的宏。首先是 %.o:%.c，这是一个模式规则，表示所有的 .o 目标都依赖于与它同名的 .c 文件（当然还有 deps 中列出的头文件）。再来就是命令部分的 $< 和 $@，其中 $< 代表的是依赖关系表中的第一项（如果我们想引用的是整个关系表，那么就应该使用 $^），具体到我们这里就是 %.c。而 $@ 代表的是当前语句的目标，即 %.o。这样一来，make 命令就会自动将所有的 .c 源文件编译成同名的 .o 文件。不用我们一项一项去指定了。整个代码自然简洁了许多。

基本的正则表达式

Sun, 05 Jun 2022 11:28:34 +0000

基本的正则表达式，记录一下，方便之后查询；

基本的正则表达式：

在线练习

1. 基本匹配

正则表达式其实就是在执行搜索时的格式，它由一些字母和数字组合而成。例如：一个正则表达式 the，它表示一个规则：由字母t开始，接着是h，再接着是e。

"the" => The fat cat sat on the mat.

正则表达式123匹配字符串123。它逐个字符的与输入的正则表达式做比较。

正则表达式是大小写敏感的，所以The不会匹配the。

"The" => The fat cat sat on the mat.

2. 元字符

正则表达式主要依赖于元字符。元字符不代表他们本身的字面意思，他们都有特殊的含义。一些元字符写在方括号中的时候有一些特殊的意思。以下是一些元字符的介绍：

元字符描述.句号匹配任意单个字符除了换行符。[ ]字符种类。匹配方括号内的任意字符。否定的字符种类。匹配除了方括号里的任意字符匹配>=0 个重复的在号之前的字符。+匹配>=1 个重复的+号前的字符。?标记?之前的字符为可选.{n,m}匹配 num 个大括号之间的字符 (n <= num <= m).(xyz)字符集，匹配与 xyz 完全相等的字符串.|或运算符，匹配符号前或后的字符.\转义字符,用于匹配一些保留的字符 { } . * + ? ^ $ \ |^从开始行开始匹配.$从末端开始匹配.

2.1 点运算符 .

.是元字符中最简单的例子。 .匹配任意单个字符，但不匹配换行符。例如，表达式.ar匹配一个任意字符后面跟着是a和r的字符串。

".ar" => The car parked in the garage.

2.2 字符集

字符集也叫做字符类。方括号用来指定一个字符集。在方括号中使用连字符来指定字符集的范围。在方括号中的字符集不关心顺序。例如，表达式[Tt]he 匹配 the 和 The。

Linux_grep命令使用

Sun, 05 Jun 2022 07:40:21 +0000

最近在学Linux，发现grep命令很常用，所以记录一下，方便之后查询；

grep命令常见用法

1、字符串搜索：

在文件中搜索一个单词，命令会返回一个包含 “match_pattern” 的文本行：

grep match_pattern file_name
grep "match_pattern" file_name

例子：

2、在多个文件中查找字符串：

grep "match_pattern" file_1 file_2 file_3 ...

例子：

3、输出除之外的所有行 -v 选项：

grep -v "match_pattern" file_name

例子：

4、标记匹配颜色

—color=auto 选项：

grep "match_pattern" file_name --color=auto

例子：

5、使用正则表达式：

使用正则表达式 -E 选项：

grep -E "[1-9]+"
# 或
egrep "[1-9]+"

使用正则表达式 -P 选项：

grep -P "(\d{3}\-){2}\d{4}" file_name

只输出文件中匹配到的部分 -o 选项：

echo this is a test line. | grep -o -E "[a-z]+\."
line.

echo this is a test line. | egrep -o "[a-z]+\."
line.

6、统计文件或者文本中包含匹配字符串的行数：

-c 选项：

lvgl显示txt文本(指定字体)

Mon, 16 May 2022 03:38:12 +0000

前些天做微机课设，给小一加了几个功能，其中一个重要功能是显示中文文本；

字体取模：

屏幕要显示图案，例如某个汉字或者数字、图案等，都需要对图案进行取模操作；

使用的是LvglFontTool工具，LVGL官网的字体转化用于单个字体取模比较方便；批量的话，使用这个离线取模软件比较方便；

操作界面如下所示：

步骤还是很简单的：

首先选择字体，包括一个TFF字体文件还有选择需要取模的字体大小；
然后加入汉字，我是将所有常用的汉字都加入了；
然后在右边配置一些选项，按照图片上的配置就可以；
最后点击开始转换就可以生成一个myFont.c和myFont.bin文件，bin文件加载到SPI FLASH中，C文件加入Keil工程即可;

如果只需要显示数量比较少的文本，取模后得到的数组可以直接放在一个.c或者.h文件中，直接下载到单片机的FLASH中即可，但是如果要显示各种不同样式和不同大小的字体，取模后得到的文件会很大，加载到FLASH中存放是不合理的。

文件放置：

小一这一版的硬件是带了一个8M的SPI FLASH，所以取模后的数据可以放在这块SPI FLASH中，可以用哪些方法通过单片机读取bin文件中的内容呢？

一般是有两个方法：

放入移植好的Fatfs文件系统中，通过文件系统提供的接口读取该bin文件；
加载进SPI FLASH中，直接通过最底层的读取函数读取；

两种方案各有优缺点，第一种更换字体取模文件很方便，但是由于字体取模文件会频繁被读取，所以这个方案的效率会比较差；第二种方案更换字体取模文件比较麻烦，但是读取的效率会高不少。我是选择了第二种方案，第一种我也试了，效率确实不是很高。

对于第二种方案，首先要将取模文件从PC机放入SPI FLASH中，我采用的方案是将SPI FLASH划分为两部分：

前4MB 后4MB

用于存储字体取模数据用于建立文件系统

然后将SPI FLASH模拟为USB设备，插入PC机，会弹出一个U盘，将字体文件拖入；然后通过一个函数，将bin文件分段读取并分段写入SPI FLASH的前4MB部分中，具体函数如下所示：

void write_to_flash(void)
{
    uint8_t i;
    f_res = f_open(&file1, "myFont.bin", FA_READ);//打开对应文件
    count_f = 0;
    for (i = 0; i  如果有多个字体文件，可以将写入的地址偏移一个大小即可。

## 文件读取：

字体取模文件读取只需要修改`myFont.c`中的一个函数：

```c
static uint8_t __g_font_buf[324]; //如bin文件存在SPI FLASH可使用此buff
static uint8_t *__user_font_getdata(int offset, int size)
{
    //如字模保存在SPI FLASH, SPIFLASH_Read(__g_font_buf,offset,size);
    //如字模已加载到SDRAM,直接返回偏移地址即可如:return (uint8_t*)(sdram_fontddr+offset);
    my_W25QXX_Read(__g_font_buf, offset, size);
    return __g_font_buf;
}

如果有多个字体文件，可以在对应的myFont文件中将读出的地址偏移一个大小即可。

结构体中定义函数指针

Tue, 10 May 2022 06:56:37 +0000

前些天看了一个RobMaster哨兵机器人的开源代码，里边用了C语言结构体定义函数指针，看得有点迷糊，所以自己查了一些相关的资料；

C语言结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。所以，标准C中的结构体是不允许包含成员函数的，当然C++中的结构体对此进行了扩展。那么，我们在C语言的结构体中，只能通过定义函数指针的方式，用函数指针指向相应函数，以此达到调用函数的目的。

结构体定义：

struct data_demo
{
  int result;
  int (*add)(int, int);
  int (*sub)(int, int);
};

完整例子：

#include
struct data_demo
{
    int result;
    int (*add)(int, int);
    int (*sub)(int, int);
};
int add_demo(int i, int j)
{
    return i+j;
}
int sub_demo(int i, int j)
{
    return i-j;
}
int main(void)
{
    struct data_demo data =  {0, add_demo, sub_demo};
    // 也可以如下初始化结构体 完全等价
    /*
    struct data_demo data =
    {
        .result = 0,
        .add = add_demo,
        .sub = sub_demo
    };
    */
    data.result = data.add(20, 30);
    printf("add:\t%d\n", data.result);
    data.result = data.sub(30, 20);
    printf("sub:\t%d\n", data.result);
    return 0;
}

运行结果：

常用的通信协议

Mon, 09 May 2022 13:38:00 +0000

常用通讯协议(SPI、IIC、UART)；

一、USART和UART:

USART:通用同步异步收发器，USART是一个串行通信设备，可以灵活地与外部设备进行全双工数据交换。

UART: 通用异步收发器，异步串行通信口(UART)就是我们在嵌入式中常说的串口，它还是一种通用的数据通信议。

异步通讯时二者无区别，同步通讯时USART可以提供主动时钟。

均为全双工通信。

起始位：先发出一个逻辑”0”的信号，表示传输数据的开始。数据位：传输N bits。校验位(可选)：数据位加上这一位后，使得“1”的位数应为偶数(偶校验)或奇数(奇校验)，以此来校验数据传送的正确性。如传输“A”(01000001)为例,”A”字符的8个bit位中有两个1。当为奇数校验时该位为1；当为偶数校验时该位为0。停止位：它是一帧数据的结束标志。可以是1bit、1.5bit、2bit的空闲电平。空闲位：没有数据传输时线路上的电平状态。为逻辑1。传输方向：即数据是从高位(MSB)开始传输还是从低位(LSB)开始传输。比如传输“A”如果是MSB那么就是01000001，如果是LSB那么就是10000010 帧间隔：即传送数据的帧与帧之间的间隔大小，可以以位为计量也可以用时间(知道波特率那么位数和时间可以换算)。比如传送”A”完后，这为一帧数据，再传”B”，那么A与B之间的间隔即为帧间隔。波特率定义：有效数据信号调制载波的速率，每秒传输1或0的个数；例如：串口传输速率为9600bps，每秒可传输多少字节？起始位：1 数据位：8 停止位：1 校验位：0 传输1字节数据，需要传输10bit，因此： 9600 ÷ 10 = 960Byte

二、IIC通讯协议：

IIC协议为半双工协议。

全双工指在发送数据的同时也能够接收数据；

半双工就是指一个时间段内只有一个动作发生；

数据有效传输在scl信号的高电平期间，sda数据线保持稳定，在scl为低电平时允许sda数据线变化。

起始条件在scl为高电平期间，sda出现下降沿，则为起始信号。

结束条件在scl为高电平期间，sda出现上升沿，则为结束信号。

注意：注意起始和终止信号都是由主机发出的，总线在起始条件之后，视为忙状态，在停止条件之后被视为空闲状态。应答（ACK，Acknowledgement）。即确认字符，在数据通信中，接收站发给发送站的一种传输类控制字符。主机每向从机发送完一个字节的数据，主机总是需要等待从机给出一个应答信号，来确认从机是否成功接收到了数据，从机应答主机所需要的时钟也是由主机提供的，应答出现在每一次主机完成8个数据位传输后紧跟着的时钟周期，低电平0表示应答，1表示非应答。，需要应答时，数据发出方将SDA总线设置为3态输入，由于IIC总线上有上拉电阻，因此此时总线默认高电平，若数据接收方正确接收到数据，则数据接收方将SDA总线拉低，以示正确应答。

IIC传输时时从MSB开始传输到LSB结束。MSB是Most Significant Bit的缩写，最高有效位。在二进制数中，MSB是最高加权位。与十进制数字中最左边的一位类似。通常，MSB位于二进制数的最左侧，LSB位于二进制数的最右侧。LSB，英文 least significant bit，中文义最低有效位。

写时序：

ID_Address, REG_Address, W_REG_Data

产生start位；传送器件地址ID_Address，器件地址的最后一位为数据的传输方向位，R/W，低电平0表示主机往从机写数据（W），1表示主机从从机读数据（R）。ACK应答，应答是从机发送给主机的应答，这里不用管；传送写入器件寄存器地址，即数据要写入的位置。同样ACK应答不用管；传送要写入的数据。ACK应答不用管；产生stop信号；

读时序：

{ID_Address + REG_Address} + {ID_Address + R_REG_Data}

产生start信号传送器件地址（写ID_Address），ACK。传送字地址（写REG_Address），ACK。再次产生start信号再传送一次器件地址，ACK。读取一个字节的数据，读数据最后结束前无应答ACK信号。产生stop信号。

判断大端和小端模式

Mon, 09 May 2022 13:28:46 +0000

测试自己的电脑是小端模式还是大端模式；

方法一：地址转换

将int 48存起来，然后取得其地址，再将这个地址转为char* ，这时候，如果是小端存储，那么char*指针就指向48；

48对应的ASCII码为字符0；

void judge_bigend_littleend1()
{
    int i = 48;
    int* p = &i;
    char c = 0;
    c = *((char*)p);
    if (c == '0')
        printf("小端\n");
    else
        printf("大端\n");
}

方法二：同方法一

定义变量int i=1;将 i 的地址拿到，强转成char*型，这时候就取到了 i 的低地址，这时候如果是1就是小端存储，如果是0就是大端存储。

void judge_bigend_littleend2()
{
    int i = 1;
    char c = (*(char*)&i);
    if (c)
        printf("小端\n");
    else
        printf("大端\n");
}

方法三：利用联合体对齐规则

定义联合体，一个成员是多字节，一个是单字节，给多字节的成员赋一个最低一个字节不为0，其他字节为0 的值，再用第二个成员来判断，如果第二个字节不为0，就是小端，若为0，就是大端。

void judge_bigend_littleend3()//因为联合体小的总是在低位
{
    union
    {
        int i;
        char c;
    }un;
    un.i = 1;
    if (un.c == 1)
        printf("小端\n");
    else
        printf("大端\n");
}

CAN通讯解析

Sun, 08 May 2022 02:52:45 +0000

CAN通讯解析；

控制器局域网 (Controller Area Network，简称CAN或者CAN bus) 是一种功能丰富的车用总线标准。被设计用于在不需要主机（Host）的情况下，允许网络上的单片机和仪器相互通信。它基于[消息传递协议，设计之初在车辆上采用复用通信线缆，以降低铜线使用量，后来也被其他行业所使用。

CAN创建在基于信息导向传输协定的广播机制（Broadcast Communication Mechanism）上。其根据信息的内容，利用信息标志符（Message Identifier，每个标志符在整个网络中独一无二）来定义内容和消息的优先顺序进行传递，而并非指派特定站点地址（Station Address）的方式。

因此，CAN拥有了良好的弹性调整能力，可以在现有网络中增加节点而不用在软、硬件上做出调整。除此之外，消息的传递不基于特殊种类的节点，增加了升级网络的便利性。

架构：

CAN是一个用于连接电子控制单元（ECU）的多主机串行总线标准。电子控制单元有时也被称作节点。CAN网络上需要至少两个节点才可进行通信。节点的复杂程度可以只是简单的输入输出设备，也可以是包含有CAN交互器并搭载了软件的嵌入式组件。节点还可能是一个网关，允许普通计算机通过USB或以太网端口与CAN网络上的设备通信。

所有节点通过两根平行的总线连接在一起。两条电线组成一条双绞线，并且接有120Ω的特性阻抗。

ISO 11898-2，也称为高速度CAN。它在总线的两端均接有120Ω电阻。

高速CAN网络 ISO 11898-2

高速CAN总线在传输显性（0）信号时，会将CAN_H端抬向5V高电平，将CAN_L拉向0V低电平。当传输隐性（1)信号时，并不会驱动CAN_H或者CAN_L端。显性信号CAN_H和CAN_L两端差分标称电压为2V。终端电阻在没有驱动时，将差分标称电压降回0V。显性信号（0）的共模电压需要在1.5V到3.5V之间。隐性信号（1）的共模电压需要在+/-12V。

高速CAN信令 ISO 11898-2

ISO 11898-3，也被称作低速或者容错CAN。它使用线性主线，星形主线或者连接到一个线性主线上的多星结构主线著称。每个节点都有终端电阻作为全局终端电阻的一部分。全局终端电阻不应低于100 Ω。

低速容错CAN网络 ISO 11898-3

低速/容错CAN信号在传输显性信号（0）时，驱动CANH端抬向5V，将CANL端降向0V。在传输隐性信号（1）时并不驱动CAN 总线的任何一端。在电源电压Vcc为5V时，显性信号差分电压需要大于2.3V，隐性信号的差分电压需要小于0.6V。CAN总线两端未被驱动时，终端电阻使CANL端回归到RTH电压（当电源电压Vcc为5V时，RTH电压至少为Vcc-0.3V=4.7V），同时使CANH端回归至RTL电压（RTL电压最大为0.3V）。两根线需要能够承受-27V至40V的电压而不被损坏。

低速CAN信令 ISO 11898-3

在高速和低速CAN中,从隐性信号向显性信号过渡的速度更快，因为此时CAN线缆被主动积极地驱动。显性向隐性的过渡速度主要取决于CAN网络的长度和导线的电容。

高速CAN通常被用于汽车和工业应用，在这些应用环境中，总线通常从一端横跨至另一端。容错CAN总线则经常被用在需要连接在一起的一组节点。

ISO规格只要求总线共模电压必须保持在最小和最大范围内，但不定义如何将总线电压保持在这个范围。

CAN总线必须使用终端电阻。终端电阻可以用来抑制信号反射，同时可以使总线电压回到隐性状态或者闲置状态。

高速CAN在总线两端使用120Ω电阻。低速CAN在每个节点均使用电阻。也有其他类型的终端，例如ISO 11783中定义了终端偏压电路。

终端偏压电路使用由4条导线组成的线缆，除了CAN信号线以外还有电源线和地线。这在每段总线两端提供自动偏压和终端功能。ISO11783网络是专为热拔插总线段和电子控制单元设计的。

CAN通信节点：

每个节点需要:

中央处理器、微处理器或主处理器处理主机决定收到的信息的意思以及想要传输的信息。
传感器、驱动器和控制设备可以与主处理器连接。
CAN控制器；通常是集成单片机的一部分接收：CAN控制器将从总线上接收的串位字节存储直到整个消息可用，之后主处理器可以获取这个消息（通常由于CAN控制器触发一个中断）。
发送：主处理器发送传递信息到CAN控制器，之后当总线空闲时将串位信息传递至总线。
收发器；由ISO11898-2/3介质访问单元（MAU）标准定义接收：把数据流从CAN总线层转换成CAN控制器可以使用的标准。 CAN控制器通常配有保护电路。
传输：把来自CAN控制器的数据流转换至CAN总线层。

每个节点能够发送和接收信息，但不是同时进行的。一个消息或帧主要包括标识符(ID)，它表示信息的优先级，最多八个数据字节。CRC、ACK和其他帧部分也是消息的一部分。改进了的CAN FD将每个帧拓展至最多64字节。消息采用不归零(NRZ)格式串联传送到主线并可被所有节点接收。

被CAN网络连接的设备通常是传感器，驱动器和其他控制设备。这些设备通过一个中央处理器、一个CAN控制器和一个CAN接收器连接至总线。

数据传输：

CAN数据传输如果出现争执，将会使用无损位仲裁解决办法。该仲裁法要求CAN网络上的所有节点同步，对每一位的采样都在同一时间。这就是为什么有人称之为CAN同步。然而，同步这个术语在此并不精确，因为数据以异步格式传输而不包含时钟信号。

stm32启动过程

Sun, 08 May 2022 02:14:32 +0000

了解stm32的启动过程，方便遇到问题时的调试；

主要是两个问题：

STM32是如何启动的，如何执行到main函数；
如何保证编译后的代码可以烧录到正确的地址；

作为一个计算机系统的核心，CPU的实际工作就是取指令和计算。大体上它可以看做是三个部分组成的：寄存器组、算术逻辑单元(ALU) 、指令队列。在Cortex-M4的寄存器中有一个特殊的寄存器PC(Program Counter,程序计数器)，用于控制程序的执行。在每个时钟周期中CPU都会根据PC中的值，从地址空间中取一条指令放到指令队列中，同时从指令队列中取出一条指令进行解析和运算(实际上ARM采用的是一种流水线的指令处理方式，与这里所讲的内容还是有很大差异的，但大体思想差不多)。并把上次的运算结果写到寄存器中。

CPU运算所用的指令和数据都来自地址空间。在Cortex-M4的内存系统中， CPU可以访问4G的地址空间，根据所映射的物理对象不同大体上被划分成了6块。我们烧写到芯片内部的程序一般都在其中的Code段中，在STM32中这个段对应的是一块FLASH。上电的时候，基本上只有这块FLASH中的内容是确定的，其它地址空间以及CPU内部的寄存器中的值都是随机的。当然为了防止上电的时候外设产生意外，片上外设(Peripheral)段中的值在上电的时候也会有初始值。

所以，从处理器的角度来看，启动过程实际上是给各个寄存器赋初值的过程，更具体的是给PC寄存器赋初值的过程。从MCU和系统的角度来看，启动过程是初始化处理器和外设的过程。

以STM32F4为例：

STM32是如何启动的：

上电后系统进行复位，等到时钟稳定后才可以正常工作，这个过程通常需要几个毫秒。图1中描述了处理器的复位过程，Cortex-M内核会先从地址0x0000处读取栈地址，并写到CPU内部的SP寄存器中。再从地址0x0004读取Reset Vector到PC寄存器中，进而跳转到Reset Vector所指的地址上开始执行程序。

图1 Cortex-M复位流程

栈空间是处理器实现函数调用和中断服务的工具。函数调用和中断服务有一个共同的特点就是，它们都需要先把当前正在处理的内容暂时保存下来，转而执行要调用的函数，或者中断服务函数，等待新的函数执行完毕返回后，在从原来保存的内容恢复回来继续执行原来的函数。而函数的调用是支持嵌套的，也就是说一个函数中可以调用子函数，在子函数中又可以调用其它子函数。那么从函数的调用和返回的顺序上来看，最后调用的函数一定先返回。栈这种数据结构的特点就是其中的数据是后进先出的，与函数调用和返回的顺序是一致的。因而，人们就专门在内存空间中划分出来一块用作栈空间，并从CPU中拿出一个宝贵的寄存器用于指示栈顶，该寄存器被记为SP (Stack Pointer)。

所以，前面所说的从CPU的角度看启动过程就是PC寄存器初始化的过程还不完善。虽然对PC寄存器进行初始化后，CPU就可以正常的取指令并进行运算了，但这时所能完成的功能十分有限，并不能支持对我们很重要的函数和中断。因此，从CPU角度看启动过程是对PC和SP两个寄存器的初始化过程。

Cortex-M4中规定0x0000起始的地址存放的是系统向量表(vector table)。在STM32中0x0000本身并不对应什么物理设备， ==通过配置引脚BOOT[1:0]我们可以控制0x0000映射到地址空间中的其它地址中，也就实现了不同的启动方式。==一共有三种可选的启动方式如表1所示，从主闪存或者系统存储器启动时，硬件上会把0x0000 0000映射到0x0800 0000或者0x1FFF F000上，这样我们从地址0x0000 0000访问的空间实际上就是主闪存或者系统存储器的空间。从SRAM启动时，只能在0x2000 0000开始的地址访问SRAM。一般我都是从主闪存启动的，也就是说系统的向量表应当烧写在0x0800 0000的地址上。至于如何从SRAM启动需要查看其他资料todo。

启动模式选择引脚

启动模式偏移地址

BOOT1 BOOT0

X 0 主闪存(Main Flash Memory) 0x0800 0000

0 1 系统存储器(system memory) 0x1FFF F000

1 1 内置SRAM(Embedded SRAM) 0x2000 0000

python向bin文件添加CRC32校验码

Sat, 07 May 2022 05:01:21 +0000

python向bin文件添加CRC32校验码；

1、keil添加配置，编译后调用脚本生成bin文件

D:\Keil_v5\ARM\ARMCC\bin\fromelf.exe --bin -o fromelf --bin -o "$L@L.bin" "#L"

2、keil添加配置，调用python脚本，向bin文件中插入crc32校验码

python ./crc32_bin.py

python脚本如下：

# -*- coding:utf-8 -*-
import binascii
import os
import sys

def crc2hex(crc):
    res=''
    for i in range(4):
        t=crc & 0xFF
        crc >>= 8
        res='%02X%s' % (t, res)
    return res
inputfile = "E:\IAP\APP\Project\OBJ\STM32F407.bin"#实际存放的bin文件路径
isfile = os.path.isfile(inputfile);
print(inputfile);
fp = open(inputfile, "r+b")  #直接打开一个文件，如果文件不存在则创建文件
filesize = os.path.getsize(inputfile)
print("ZI app firmware size:", filesize, "bytes.")

#计算bin文件的CRC，首先清空CRC32区域的4个byte
fp.seek(0x1c, 0)#从bin文件开始，偏移地址为0x1c的地方存放bin的CRC32
clear4bytes = '00000000'
c4 =binascii.unhexlify(clear4bytes)
fp.write(c4)  #将CRC32存放的区域4bytes清零
fp.seek(0, 0)#从0开始读取整个bin
file_content = fp.read()#读整个文件内容到 file_content
crc = binascii.crc32(file_content)
print('CRC32:', hex(crc))

fp.seek(0x1c, 0)#从bin文件开始，偏移地址为0x1c的地方存放bin的CRC32
#存放计算CRC32四个字节
crcstr_2 = crc2hex(crc)
r=binascii.unhexlify(crcstr_2)
fp.write(r)
fp.close()
sys.exit(0)##正常退出

这个脚本我是用在stm32 Bootloader中的，因为经串口或其他方式接收到的程序未必是正确的，而且有时候会加入版本信息什么的，所以加入CRC校验可以方便的检验文件完整性。

FreeRTOS基础知识

Fri, 06 May 2022 08:58:30 +0000

FreeRTOS学习记录；

FreeRTOS学习记录

一、任务管理

任务函数：

void ATaskFunction( void *pvParameters );

每一个任务函数都有自己的栈空间、自动变量；
函数里通常是一个死循环；
一般函数有可能跳出死循环，则必须删除函数：

void ATaskFunction( void *pvParameters )
{
	/* 可以像普通函数一样定义变量。用这个函数创建的每个任务实例都有一个属于自己的iVarialbleExample变
	量。但如果iVariableExample被定义为static，这一点则不成立 – 这种情况下只存在一个变量，所有的任务实
	例将会共享这个变量。 */
	int iVariableExample = 0;
	/* 任务通常实现在一个死循环中。 */
	for( ;; )
	{
	/* 完成任务功能的代码将放在这里。 */
	}
	/* 如果任务的具体实现会跳出上面的死循环，则此任务必须在函数运行完之前删除。传入NULL参数表示删除
	的是当前任务 */
	vTaskDelete( NULL );
}

任务创建函数：

portBASE_TYPE xTaskCreate( pdTASK_CODE pvTaskCode,
                            const signed portCHAR * const pcName,
                            unsigned portSHORT usStackDepth,
                            void *pvParameters,
                            unsigned portBASE_TYPE uxPriority,
                            xTaskHandle *pxCreatedTask );

pvTaskCode 任务只是永不退出的 C 函数，实现常通常是一个死循环。参数 pvTaskCode 是一个指向任务的实现函数的指针(效果上仅仅是函数名)。

union和struct存放格式

Fri, 06 May 2022 08:55:37 +0000

union、struct所占的空间大小；

union:

当多个数据需要共享内存或者多个数据每次只取其一时，可以利用联合体(union)。在C Programming Language 一书中对于联合体是这么描述的：

联合体是一个结构； 它的所有成员相对于基地址的偏移量都为0； 此结构空间要大到足够容纳最”宽”的成员； 其对齐方式要适合其中所有的成员；

下面解释这四条描述：

由于联合体中的所有成员是共享一段内存的，因此每个成员的存放首地址相对于于联合体变量的基地址的偏移量为0，即所有成员的首地址都是一样的。为了使得所有成员能够共享一段内存，因此该空间必须足够容纳这些成员中最宽的成员。对于这句“对齐方式要适合其中所有的成员”是指其必须符合所有成员的自身对齐方式。

例如：

#include
using namespace std;
union A{
   int a[5];
   char b;
   double c;
};
int main(){
   cout

**a**

**b**
**b**
**b**
**b**

**c**
**c**

```c++
//例如：
struct B
{
    char a;
    short b;
    int c;
}
//则sizeof(A)大小应该是4+4=8字节

a c c

b b b b

//例如：
struct B
{
    char a;
    char b[2];
    char c[4];
}
//则sizeof(A)大小应该是1+2+4=7字节

a b b c c c c

常用脚本汇总

Fri, 22 Apr 2022 02:44:42 +0000

图片PNG文件转JPG文件；

使用方法：将该脚本放置于png文件所在的文件夹中，然后运行该脚本，即可将png文件转化为jpg文件，并放置于JPG文件夹下；

import os
from PIL import Image
dirname_read = "./"  								# 源文件文件夹
dirname_write = "./JPG/"  							# 目标文件文件夹
names = os.listdir(dirname_read)
count = 0
for name in names:
    portion = os.path.splitext(name)  				# 分离文件名和扩展名
    if portion[1] == ".png":          				# 判断扩展名是否为png
        img = Image.open(dirname_read+name) 		# 打开该文件
        name = portion[0] + ".jpg" 					# 重命名文件
        to_save_path = dirname_write + name 		# 设置保存路径
        img = img.convert('RGB')
        # RGBA意思是红色，绿色，蓝色,Alpha指透明度。而JPG不支持透明度，所以要么丢弃Alpha,要么保存为.png文件
        img.save(to_save_path, quality=95)  		# 保存
        count += 1  								# 计数加一
        print(to_save_path, "------conut:", count)  # 输出信息
    else:
        continue
print("Count_Sum:", count)  						# 输出总数

PID中积分饱和及其解决办法

Thu, 10 Mar 2022 02:41:07 +0000

PID控制中常出现的积分饱和概念及其解决方案；

积分饱和的概念：

这种现象往往发生在误差有大幅变化（例如大幅增加），积分器因为误差的大幅增加有很大的累计量，因为积分器的输出满足下式：

离散化形式表示为：

所以随着时间的增加，每次累积较大的误差，很容易造成积分饱和并产生较大的过冲，而且当误差变为负时，其过冲仍维持一段时间之后才恢复正常的情形。

通常会产生的输出如下图所示：

从图中我们不难发现，这里有三个过程：

因为这个过程存在较大幅度变化的误差，因此积分器累积了较大的值，从图中可以看到，积分器的面积比较大（阴影部分）；
此时积分已经饱和，产生了较大的过冲，并且在较长的一段时间内，一直处于过冲的状态；
积分脱离饱和状态，产生了积极的调节作用，消除静差，系统输出达到设定值；

如何防止积分饱和：

为了防止PID控制器出现积分饱和，需要在算法加入抗积分饱和（anti-integral windup）的算法；通常有以下几种措施；

积分分离或者称为去积分算法；
在饱和的时候将积分器的累计值初始化到一个比较理想的值；
若积分饱和因为目标值突然变化而产生，将目标值以适当斜率的斜坡变化可避免此情形；
将积分累计量限制上下限，避免积分累计量超过限制值；
如果 PID输出已经饱和，则重新计算积分累计量，使输出恰好为合理的范围；

参考：

1、一文详细解析到底什么是积分饱和；

Jlink使用RTT输出调试信息(代替串口打印)

Tue, 15 Feb 2022 04:02:47 +0000

Jlink RTT调试技巧；

使用Jlink的 RTT功能 :

这个功能是不需要另外接其他引脚的，如果使用SW连接方式，仅仅两根线就可以。

RTT 是Jlink的一种实时终端的方式连接输出调试信息，网上有很多说明之间按照做就可以，我仅仅是记录一下自己的步骤.

就是下载RTT软件包，下载RTT文件： http://download.segger.com/J-Link/RTT/RTT_Implementation_140925.zip ；

添加RTT文件到自己的工程：添加必要的头文件：

输出函数打印：

这个时候RTT在程序中就添加成功了，我们可以使用使用Jlink带的工具进行查看数据；

如打开RTT Viewer 提升连接，点击OK 不出意外的话，你就可以看到调试信息了；

markdown绘制简单流程图

Mon, 07 Feb 2022 09:26:35 +0000

Markdown绘制简单流程图；

Typora流程图：

mermaid效果（这个可以在Typora编辑器中显示，博客中渲染失败）

输入```，然后输入mermaid即可

·mermaid
graph TD
   B((开始)) -->C{判断}
   C --  a=1 -->D[执行语句1]
   C --  a=2  -->E[执行语句2]
   C --  a=3 -->F[执行语句3]
   C -- a=4  -->G[执行语句4]
   D--> AA((结束))
   E--> AA
   F--> AA
   G--> AA

如下图：

语法：

官网说明文档 Mermaid .

flowchar效果（只有这个可以在博客中显示流程图）

···flow
st=>start: 开始节点
in=>inputoutput: 输入
e=>end: 结束节点
op=>operation: 操作节点
cond=>condition: 条件节点
sub=>subroutine: 子例程
out=>inputoutput: 输出
st(right)->in->op->cond
cond(yes,right)->out->e
cond(no)->sub

实际例子1：

···flow
st=>start: Start
i=>inputoutput: 输入年份n
cond1=>condition: n能否被4整除？
cond2=>condition: n能否被100整除？
cond3=>condition: n能否被400整除？
o1=>inputoutput: 输出非闰年
o2=>inputoutput: 输出非闰年
o3=>inputoutput: 输出闰年
o4=>inputoutput: 输出闰年
e=>end
st->i->cond1
cond1(no)->o1->e
cond1(yes)->cond2
cond2(no)->o3->e
cond2(yes)->cond3
cond3(yes)->o2->e
cond3(no)->o4->e

实际例子2：

LCD显示太空人画面

Mon, 24 Jan 2022 09:52:39 +0000

LCD 显示太空人动画；

这个比较简单，就是把连续的画面播放起来就行；

自制Jlink-OB(带串口)

Sun, 23 Jan 2022 02:14:20 +0000

自制Jlink-ob(带串口)；

CRC校验原理

Sat, 08 Jan 2022 02:21:29 +0000

之前经常用CRC校验，今天解释一下其原理；

简单介绍：

Cyclic Redundancy Check循环冗余检验，是基于数据计算一组效验码，用于核对数据传输过程中是否被更改或传输错误。

循环冗余校验检错方案（CRC）：

CRC校验原理看起来比较复杂，好难懂，因为大多数书上基本上是以二进制的多项式形式来说明的。其实很简单的问题，其根本思想就是先在要发送的帧后面附加一个数（这个就是用来校验的校验码，但要注意，这里的数也是二进制序列的，下同），生成一个新帧发送给接收端。当然，这个附加的数不是随意的，它要使所生成的新帧能与发送端和接收端共同选定的某个特定数整除（注意，这里不是直接采用二进制除法，而是采用一种称之为“模2除法”）。到达接收端后，再把接收到的新帧除以（同样采用“模2除法”）这个选定的除数。因为在发送端发送数据帧之前就已通过附加一个数，做了“去余”处理（也就已经能整除了），所以结果应该是没有余数。如果有余数，则表明该帧在传输过程中出现了差错。

【说明】：“模2除法”与“算术除法”类似，但它既不向上位借位，也不比较除数和被除数的相同位数值的大小，只要以相同位数进行相除即可。模2加法运算为：1+1=0，0+1=1，0+0=0，无进位，也无借位；模2减法6运算为：1-1=0，0-1=1，1-0=1，0-0=0，也无进位，无借位。相当于二进制中的逻辑异或运算。也就是比较后，两者对应位相同则结果为“0”，不同则结果为“1”。如100101除以1110，结果得到商为11，余数为1，如图5-9左图所示。如11×11=101，如右图所示。

“模2除法”和“模2乘法”示例

具体来说，CRC校验原理就是以下几个步骤：

先选择（可以随机选择，也可按标准选择，具体在后面介绍）一个用于在接收端进行校验时，对接收的帧进行除法运算的除数（是二进制比较特串，通常是以多项方式表示，所以CRC又称多项式编码方法，这个多项式也称之为“生成多项式”）。
看所选定的除数二进制位数（假设为k位），然后在要发送的数据帧（假设为m位）后面加上k-1位“0”，然后以这个加了k-1个“0“的新帧（一共是m+k-1位）以“模2除法”方式除以上面这个除数，所得到的余数（也是二进制的比特串）就是该帧的CRC校验码，也称之为FCS（帧校验序列）。但要注意的是，余数的位数一定要是比除数位数只能少一位，哪怕前面位是0，甚至是全为0（附带好整除时）也都不能省略。
再把这个校验码附加在原数据帧（就是m位的帧，注意不是在后面形成的m+k-1位的帧）后面，构建一个新帧发送到接收端；最后在接收端再把这个新帧以“模2除法”方式除以前面选择的除数，如果没有余数，则表明该帧在传输过程中没出错，否则出现了差错。

通过以上介绍，大家一定可以理解CRC校验的原理，并且不再认为很复杂吧。从上面可以看出，CRC校验中有两个关键点：一是要预先确定一个发送端和接收端都用来作为除数的二进制比特串（或多项式）；二是把原始帧与上面选定的除进行二进制除法运算，计算出FCS。前者可以随机选择，也可按国际上通行的标准选择，但最高位和最低位必须均为“1”，如在IBM的SDLC（同步数据链路控制）规程中使用的CRC-16（也就是这个除数一共是17位）生成多项式g（x）= x^16 + x^15 + x^2 +1（对应二进制比特串为：11000000000000101）；而在ISO HDLC（高级数据链路控制）规程、ITU的SDLC、X.25、V.34、V.41、V.42等中使用CCITT-16生成多项式g（x）= x^16+ x^15 + x^5 +1（对应二进制比特串为：11000000000100001）。

CRC校验码的计算示例

由以上分析可知，既然除数是随机，或者按标准选定的，所以CRC校验的关键是如何求出余数，也就是校验码（CRC校验码）。下面以一个例子来具体说明整个过程。现假设选择的CRC生成多项式为G（X） = X^4 + X^3 + 1，要求出二进制序列10110011的CRC校验码。下面是具体的计算过程：

首先把生成多项式转换成二进制数，由G（X） = X^4+ X^3 + 1可以知道，它一共是5位（总位数等于最高位的幂次加1，即4+1=5），然后根据多项式各项的含义（多项式只列出二进制值为1的位，也就是这个二进制的第4位、第3位、第0位的二进制均为1，其它位均为0）很快就可得到它的二进制比特串为11001。
因为生成多项式的位数为5，根据前面的介绍，得知CRC校验码的位数为4（校验码的位数比生成多项式的位数少1）。因为原数据帧10110011，在它后面再加4个0，得到101100110000，然后把这个数以“模2除法”方式除以生成多项式，得到的余数（即CRC码）为0100，如图所示。注意参考前面介绍的“模2除法”运算法则。

CRC校验码计算示例

把上步计算得到的CRC校验0100替换原始帧101100110000后面的四个“0”，得到新帧101100110100。再把这个新帧发送到接收端。
当以上新帧到达接收端后，接收端会把这个新帧再用上面选定的除数11001以“模2除法”方式去除，验证余数是否为0，如果为0，则证明该帧数据在传输过程中没有出现差错，否则出现了差错。

通过以上CRC校验原理的剖析和CRC校验码的计算示例的介绍，大家应该对这种看似很复杂的CRC校验原理和计算方法应该比较清楚了。

算法原理：

假设数据传输过程中需要发送15位的二进制信息g=101001110100001，这串二进制码可表示为代数多项式g(x) = x^14 + x^12 + x^9 + x^8 + x^7 + x^5+ 1，其中g中第k位的值，对应g(x)中x^k 的系数。将g(x)乘以x^m，既将g后加m个0，然后除以m阶多项式h(x)，得到的(m-1)阶余项r(x)对应的二进制码r就是CRC编码。

h(x)可以自由选择或者使用国际通行标准，一般按照h(x)的阶数m，将CRC算法称为CRC-m，比如CRC-32、CRC-64等。国际通行标准可以参看标准；

g(x)和h(x)的除运算，可以通过g和h做xor（异或）运算。比如将11001与10101做xor运算：

明白了xor运算法则后，举一个例子使用CRC-8算法求101001110100001的效验码。CRC-8标准的h(x) = x^8 + x^7 + x^6 + x^4 + x^2 + 1，既h是9位的二进制串111010101。

LVGL开发

Mon, 03 Jan 2022 05:17:26 +0000

最近要做一个GUI界面，自己开发各种功能是极其麻烦的(对的，我之前是做过的)，需要注意很多问题，而且开发起来很多功能基本上是实现不了的，所以只能想其他办法了，因为之前用LVGL做过一个很简单的GUI界面，所以这次也打算用LVGL来做，也算是再复习一下这个界面的使用。以下是关于LVGL的简介以及特点： LVGL(Light and Versatile Graphics Library，轻巧而多功能的图形库)是一个免费的开放源代码图形库，它提供创建具有易于使用的图形元素，精美的视觉效果和低内存占用的嵌入式GUI所需的一切。

LVGL主要特性

功能强大的构建块，例如按钮，图表，列表，滑块，图像等.
带有动画，抗锯齿，不透明，平滑滚动的高级图形.
各种输入设备，例如触摸板，鼠标，键盘，编码器等.
支持UTF-8编码的多语言.
多显示器支持，如TFT，单色显示器.
完全可定制的图形元素.
独立于任何微控制器或显示器使用的硬件.
可扩展以使用很少的内存(64 kB闪存，16 kB RAM)进行操作.
操作系统，支持外部存储器和GPU，但不是必需的.
单帧缓冲区操作，即使具有高级图形效果.
用C语言编写，以实现最大的兼容性(与C ++兼容).
模拟器可在没有嵌入式硬件的PC上进行嵌入式GUI设计.
可移植到MicroPython.
可快速上手的教程、示例、主题.
丰富的文档教程.
在MIT许可下免费和开源.

LVGL硬件要求

基本上，每个现代控制器(肯定必须要能够驱动显示器)都适合运行LVGL。LVGL的最低运行要求很低：

16、32或64位微控制器或处理器.
最低 16 MHz 时钟频率.
Flash/ROM:：对于非常重要的组件要求 >64 kB(建议 > 180 kB).
RAM 静态 RAM 使用量：~2 kB，取决于所使用的功能和对象类型.
堆栈： > 2kB(建议 > 8 kB).
动态数据(堆)：> 2 KB(如果使用多个对象，则建议 > 16 kB)。由 lv_conf.h 中的 LV_MEM_SIZE 宏进行设置.
显示缓冲区：> “水平分辨率”像素(建议 > 10× “水平分辨率” ).
MCU 或外部显示控制器中的一帧缓冲区.

小一升级版来了！

Wed, 22 Dec 2021 02:16:25 +0000

小一升级版；

光电传感器判断转动方向

Wed, 22 Dec 2021 01:47:01 +0000

最近接了一个项目，是做一个绕线机，一般用来绕变压器线圈，已经基本做好了，原理并不难，就是根据你输入的一些参数，比如漆包线的直径以及每一层的圈数还有就是一共要绕多少圈，然后由控制器控制步进电机根据光电传感器的信号来回运动，已达到均匀绕线的目的。

其实这个项目拖了很长时间，因为自己拖延症太严重，而且中间又发生了很多事情，导致项目中间耽搁了很久，还好甲方没有在意，也没有太催我，上周终于下定决心要结束了这个项目，于是就用了一个下午还有晚上的时间完成了这个项目，因为手头没有合适的漆包线，于是就用了直径较细的焊锡丝代替，经过测试效果很好，因为步进电机的转动是通过细分的，所以可以做到很精细的控制，经过测试，精度可以达到0.0035mm，而甲方的要求是0.01mm，也算是完全符合要求了，于是我就把测试视频发给了甲方，甲方首先给予了肯定（那是必然呀，哈哈哈哈），然后给我发了一个红包，我一个疑惑，然后他就提出了一个新的需求，就是希望能够做到反转退线的功能，并且这种情况下能做到减计数。

我思考了一下，觉得是可以做到的，用一个光电传感器是可以判断转动的次数，那用两个光电传感器就可以判断次数和转动方向，原理是根据两个光电传感器被遮挡的先后来判断转动方向，例如光电1先被遮挡，然后光电2又被遮挡，则认为是正转，反之则认为是反转，理论可行，就差一个实践了，于是就修改了一下硬件（因为第一版硬件只留出了一个光电接口，而且少画了一个二极管），又发去打了一次板，板子还没到，所以也还没开始验证，应该是可以的，所以就等之后板子到了再验证下。

板子已经到了，经过验证，完全没问题，算是满足了甲方所有的要求，很开心，也收到了剩下的款项，基本这个项目是告一段落了；下边是关于这个算法的程序：

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    uint32_t i = 0;
    if (GPIO_Pin == guangdian_Pin)
    {
        i = 65535;
        while (i--)
            ;
        i = 6553;
        while (i--)
            ;
        if (HAL_GPIO_ReadPin(guangdian_GPIO_Port, guangdian_Pin) == 0)
        {
            if (flag_stop == 0)
            {
                if (cnt_sum == 0)
                {
                    flag_dir = N0;
                }
                if (cnt_sum % N2 == 0)
                {
                    flag_dir = !flag_dir;
                }
                if (time_k1_temp

Windows使用技巧

Sat, 02 Oct 2021 08:29:25 +0000

Windows 使用技巧;

应用程序自启动

1、在Windows10桌面，右键点击桌面左下角的开始按钮，在弹出的菜单中选择”运行”菜单项. 2、这时就会打开Windows10的运行窗口，在窗口中输入命令shell:startup，然后点击确定按钮. 3、这时就可以打开Windows10系统的启动文件夹. 4、把需要开机启动的应用或是程序的快捷方式拖动到该文件夹中，这样以后电脑开机的时候，就会自动启动这些应用.

添加右键新建Markdown文档

1、在电脑桌面右键一个.txt文本(文档名随便，文档内容如下)；
Windows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\.md]
@="MarkdownFile"
"PerceivedType"="text"
"Content Type"="text/plain"
[HKEY_CLASSES_ROOT\.md\ShellNew]
[HKEY_CLASSES_ROOT\MarkdownFile]
@="Markdown File"
[HKEY_CLASSES_ROOT\MarkdownFile\DefaultIcon]
@="%SystemRoot%\system32\imageres.dll,-102"
[HKEY_CLASSES_ROOT\MarkdownFile\shell]
[HKEY_CLASSES_ROOT\MarkdownFile\shell\open]
2、修改文档的后缀为.reg； 3、双击打开这个.reg文档； 4、点击确定写进注册表； 5、在桌面右键刷新，然后新建就看到有markdown啦；

取消右键新建文件(以visio文件为例)

1、WIN+R； 2、输入regedit，enter确认，打开注册表编辑器； 3、在第一项HKEY_CLASSES_ROOT中找到对应的后缀名(例如.vsdx)； 4、删去该项的子项->ShellNew； 5、再次右键新建文件即可发现已经修改成功；

Arduino

Sat, 02 Oct 2021 08:16:16 +0000

最近做项目用到了Arduino的板子，在此记录一下开发过程中遇到的一些问题，其实我之前是很不情愿用Arduino，觉得底层都被封装起来了，而且那个IDE用起来真的是一言难尽。不过最近客户要求用Arduino进行开发，就硬着头皮上了，结果发现用VScode+Platformio开发Arduino还是顶好用的，而且有太多可以用的封装好的函数了，真香！

一个IO引脚驱动两个不同颜色的LED

用一个IO引脚驱动两个led灯

这个电路可以实现，一个IO引脚驱动两个不同颜色的LED，不过自己只测试过红色和绿色的LED，其他颜色的并没有验证，因为似乎红色和绿色对电压的要求较低。

stc单片机使用技巧

Thu, 30 Sep 2021 10:34:27 +0000

最近做项目经常用到STC的单片机，在使用过程中遇到了较多的问题，而且在后续的硬件搭建过程中也积累了不少的经验，因此打算记录一下，方便以后的查询。

蜂鸣器驱动电路

Thu, 30 Sep 2021 10:34:27 +0000

最近做项目用到了51单片机驱动蜂鸣器，但是一直无法驱动，后来以为是上拉电阻问题，结果发现加了上拉电阻会一直响，即使IO口输出为低电平。

后来发现还需要加一个下拉电阻以保证不受干扰。

参考：https://blog.csdn.net/qq_25814297/article/details/118696321?spm=1001.2014.3001.5506

下面就 3.3V NPN 三极管驱动有源蜂鸣器设计，从实际产品中分析电路设计存在的问题，提出电路的改进方案，使读者能从小小的蜂鸣器电路中学会分析和改进电路的方法，从而设计出更优秀的产品，达到抛砖引玉的效果。

常见错误接法

图1 为典型的错误接法，当 BUZZER 端输入高电平时蜂鸣器不响或响声太小。当 I/O 口为高电平时，基极电压为 3.3/4.7*3.3V≈2.3V，由于三极管的压降 0.6~0.7V，则三极管射极电压为 2.3-0.7=1.6V，驱动电压太低导致蜂鸣器无法驱动或者响声很小。

图2 错误接法2

图2 为第二种典型的错误接法，由于上拉电阻R2，BUZZER 端在输出低电平时，由于电阻R1和R2的分压作用，三极管不能可靠关断。

图3 为第三种错误接法，三极管的高电平门槛电压就只有 0.7V，即在 BUZZER 端输入压只要超过0.7V就有可能使三极管导通，显然0.7V的门槛电压对于数字电路来说太低了，电磁干扰的环境下，很容易造成蜂鸣器鸣叫。

图 4 为第四种错误接法，当CPU的GPIO管脚存在内部下拉时，由于 I/O 口存在输入阻抗，也可能导致三极管不能可靠关断，而且和图3一样BUZZER端输入电压只要超过0.7V就有可能使三极管导通。

以上几种用法我觉得也不能说是完全不行，对于器件的各种参数要求会比较局限，不利于器件选型，抗干扰性能也比较差。

NPN 三极管控制有源蜂鸣器常规设计

图 5 为通用有源蜂鸣器的驱动电路。电阻R1为限流电阻，防止流过基极电流过大损坏三极管。电阻R2有着重要的作用，第一个作用：R2 相当于基极的下拉电阻。如果A端被悬空则由于R2的存在能够使三极管保持在可靠的关断状态，如果删除R2则当BUZZER输入端悬空时则易受到干扰而可能导致三极管状态发生意外翻转或进入不期望的放大状态，造成蜂鸣器意外发声。第二个作用：R2可提升高电平的门槛电压。如果删除R2，则三极管的高电平门槛电压就只有0.7V，即A端输入电压只要超过0.7V 就有可能导通，添加R2的情况就不同了，当从A端输入电压达到约2.2V 时三极管才会饱和导通，具体计算过程如下：

假定β =120为晶体管参数的最小值，蜂鸣器导通电流是15mA。那么集电极电流IC=15mA。则三极管刚刚达到饱和导通时的基极电流是 IB=15mA/120=0.125mA。流经R2的电流是0.7V/3.3kΩ=0.212mA，流经R1的电流 IR1=0.212mA +0.125mA=0.337 mA。最后算出BUZZER端的门槛电压是0.7V+0.337mA× 4.7kΩ=2.2839V≈2.3V。

图中的C2为电源滤波电容，滤除电源高频杂波。C1可以在有强干扰环境下，有效的滤除干扰信号，避免蜂鸣器变音和意外发声，在 RFID射频通讯、Mifare卡的应用时，这里初步选用0.1uF 的电容，具体可以根据实际情况选择。

改进方案

蜂鸣器竟然有EMI 辐射？！在 NPN 3.3V 控制有源蜂鸣器时，在电路的 BUZZER 输入高电平，让蜂鸣器鸣叫，检测蜂鸣器输入管脚（NPN 三极管的C极处信号，发现蜂鸣器在发声时，向外发生1.87KHz，-2.91V 的脉冲信号，如图 6 所示。

GCC学习记录

Thu, 02 Sep 2021 01:20:43 +0000

GCC常用命令；

1. 什么是gcc

gcc的全称是GNU Compiler Collection，它是一个能够编译多种语言的编译器。最开始gcc是作为C语言的编译器（GNU C Compiler），现在除了c语言，还支持C++、java、Pascal等语言。gcc支持多种硬件平台。

2. gcc的特点

gcc是一个可移植的编译器，支持多种硬件平台。例如ARM、X86等等。
gcc不仅是个本地编译器，它还能跨平台交叉编译。所谓的本地编译器，是指编译出来的程序只能够在本地环境进行运行。而gcc编译出来的程序能够在其他平台进行运行。例如嵌入式程序可在x86上编译，然后在arm上运行。
gcc有多种语言前端，用于解析不同的语言。
gcc是按模块化设计的，可以加入新语言和新CPU架构的支持。
gcc是自由软件。任何人都可以使用或更改这个软件。

3. gcc编译程序的过程

gcc编译程序主要经过四个过程：

预处理（Pre-Processing）
编译（Compiling）
汇编（Assembling）
链接（Linking）

预处理实际上是将头文件、宏进行展开。编译阶段，gcc调用不同语言的编译器，例如c语言调用编译器ccl。gcc实际上是个工具链，在编译程序的过程中调用不同的工具。汇编阶段，gcc调用汇编器进行汇编。链接过程会将程序所需要的目标文件进行链接成可执行文件。汇编器生成的是可重定位的目标文件，学过操作系统，我们知道，在源程序中地址是从0开始的，这是一个相对地址，而程序真正在内存中运行时的地址肯定不是从0开始的，而且在编写源代码的时候也不能知道程序的绝对地址，所以重定位能够将源代码的代码、变量等定位为内存具体地址。下面以一张图来表示这个过程，注意过程中文件的后缀变化，编译选项和这些后缀有关。

这是GCC编译的四个步骤。

4. gcc常用选项

来看一下gcc常用选项

选项名作用

-o 产生目标（.i、.s、.o、可执行文件等）

-E 只运行C预编译器

-S 告诉编译器产生汇编程序文件后停止编译，产生的汇编语言文件拓展名为.s

-c 通知gcc取消连接步骤，即编译源码，并在最后生成目标文件

-Wall 使gcc对源文件的代码有问题的地方发出警告

-Idir 将dir目录加入搜索头文件的目录路径

-Ldir 将dir目录加入搜索库的目录路径

-llib 连接lib库

-g 在目标文件中嵌入调试信息，以便gdb之类的调试程序调试

现在我们有源文件hello.c，下面是一些gcc的使用示例：

gcc -E hello.c -o hello.i   对hello.c文件进行预处理，生成了hello.i 文件
gcc -S hello.i -o hello.s    对预处理文件进行编译，生成了汇编文件
gcc -c hello.s -o hello.o  对汇编文件进行编译，生成了目标文件
gcc hello.o -o hello 对目标文件进行链接，生成可执行文件
gcc hello.c -o hello 直接编译链接成可执行目标文件
gcc -c hello.c 或 gcc -c hello.c -o hello.o 编译生成可重定位目标文件

使用gcc时可以加上-Wall选项。下面这个例子如果不加上-Wall选项，编译器不会报出任何错误或警告，但是程序的结果却不是预期的：

VSCode格式化美化代码

Wed, 25 Aug 2021 11:04:25 +0000

vscode代码美化；

1）文件 —> 首选项

因为 VSCode 默认启用了根据文件类型自动设置tabsize的选项，在设置中添加：

"editor.detectIndentation": false

2）编辑器配置

在项目文件中新建 .editorconfig 文件为特定类型文件指定缩进大小、缩进类型（空格，或tab），是否自动插入末行等等。

root = true

[*]
charset = utf-8
indent_style = tab
indent_size = 4
insert_final_newline = true
trim_trailing_whitespace = true

[*.md]
max_line_length = off
trim_trailing_whitespace = false

3）安装 VsCode 格式化代码插件

搜索并安装 Beautify 格式化代码插件打开要格式化的文件 —> F1 —> Beautify file —> 选择你要格式化的代码类型

4）格式化对齐快捷键：

Windows： Ctrl + K + F
Windows：Shift + Alt + F
Mac： Shift + Option + F
Ubuntu： Ctrl + Shift + I

H750枚举U盘拖拽式BootLoader+外部spi_flash

Sun, 22 Aug 2021 07:31:15 +0000

程序已经写好了； Github地址:https://github.com/fan-pengfei/Bootloader_H750_SD/tree/master

oled使用技巧

Fri, 20 Aug 2021 02:19:46 +0000

OLED 局部刷新提高帧率.

待续

Stm32蓝牙串口下载

Thu, 19 Aug 2021 05:08:52 +0000

之前准备电赛的时候，需要用到无线调试器，先是上淘宝看了一下，基本都是大几百，所以想着自己自制一个，直接搞DAP无线调试器有点难，所以就用手头现有的蓝牙模块搞了一个串口无线下载器，调试的话就靠printf打印了；

也做了好几个版本，最初的版本主要有两个大的问题：

1、没有程序校验过程，不能保证单片机收到的APP程序是完整且正确的； 2、没有错误解决机制，一旦APP程序错误或者程序跑飞，就必须手动按下复位键进行复位；

为解决以上两个问题，采取了以下措施

1、对APP程序加入CRC校验； 2、加入看门狗，解决程序跑飞问题；

以下是关于这个项目的具体介绍：

一、APP程序部分

首先要有一个APP程序，与一般的程序相比，APP程序有两个地方需要进行配置：

分别如下图所示：

1、在system_stm32f4xx.c中进行修改：

2、在小锤子那里进行修改：

3、修改完毕后，进行正常的编译即可；

二、BIN文件的处理

最初的版本并没有加入crc校验，所以经常会出错，导致程序经常跑飞，所以加入了crc32校验；经检验，效果那是非常的好；为什么是采用bin文件而不是使用更容易得到的hex文件呢？原因很简单：因为写入单片机flash的程序实际就是bin文件，hex文件需要转换才能写进flash中；以上操作只是得到了hex文件，而我们需要的是bin文件，以下是对hex文件的处理过程：

1、第一步呢，当然是得到最初的bin文件；而Keil默认情况下编译成功后生成的是Hex文件，而不是bin文件，所以要将Hex文件转换为bin文件，当然是有现成的Hex转bin的程序的，但是比较麻烦，可以用Keil自带的功能完成编译后自动生成bin文件的过程，具体的方法请自行百度；

这是我的配置，仅供参考：

D:\Keil_v5\ARM\ARMCC\bin\fromelf.exe —bin -o fromelf —bin -o “$L@L.bin” “#L”

2、然后是对bin文件进行处理，也就是crc32校验码的生成以及插入该校验码到bin文件中，我用的是python脚本的方式，代码如下：

# -*- coding:utf-8 -*-
import binascii
import os
import sys

def crc2hex(crc):
    res=''
    for i in range(4):
        t=crc & 0xFF
        crc >>= 8
        res='%02X%s' % (t, res)
    return res
inputfile = "E:\IAP\APP\Project\OBJ\STM32F407.bin"#实际存放的bin文件路径
isfile = os.path.isfile(inputfile);
print(inputfile);
fp = open(inputfile, "r+b")  #直接打开一个文件，如果文件不存在则创建文件
filesize = os.path.getsize(inputfile)
print("ZI app firmware size:", filesize, "bytes.")

#计算bin文件的CRC，首先清空CRC32区域的4个byte
fp.seek(0x1c, 0)#从bin文件开始，偏移地址为0x1c的地方存放bin的CRC32
clear4bytes = '00000000'
c4 =binascii.unhexlify(clear4bytes)
fp.write(c4)  #将CRC32存放的区域4bytes清零
fp.seek(0, 0)#从0开始读取整个bin
file_content = fp.read()#读整个文件内容到 file_content
crc = binascii.crc32(file_content)
print('CRC32:', hex(crc))

fp.seek(0x1c, 0)#从bin文件开始，偏移地址为0x1c的地方存放bin的CRC32
#存放计算CRC32四个字节
crcstr_2 = crc2hex(crc)
r=binascii.unhexlify(crcstr_2)
fp.write(r)
fp.close()
sys.exit(0)##正常退出

代码我就不多解释了，应该还是挺容易看懂的；

Git学习记录

Wed, 18 Aug 2021 04:29:14 +0000

Git相关的知识；参考链接：https://zhuanlan.zhihu.com/p/94008510

Git 常用命令

初次使用时，在命令行中配置本地仓库的账号和邮箱：

$ git config --global user.name "username"
$ git config --global user.email "useremail"

初始化Git,使用 cd 命令导航到要在终端中设置版本控制的目录，现在你可以像这样初始化 Git 存储库：

git init

要开始对现有文件进行版本控制，你应该先跟踪这些文件并进行初始提交。要做到这一点，你首先需要将文件添加到 Git 中，并将它们附加到 Git 项目中。

git add
git commit -m "first commit"

还有一些更高级的方法可以将文件添加到 Git 中，从而使你的工作流程更高效。我们可以执行以下操作，而不是试图查找所有有更改的文件并逐个添加它们：

# 逐个添加文件
git add filename
# 添加当前目录中的所有文件
git add -A
# 添加当前目录中的所有文件更改
git add .
# 选择要添加的更改（你可以 Y 或 N 完成所有更改）
git add -p

远程备份文件（Github）,因此，首先转到 http://github.com 并创建一个存储库。然后，使用存储库的链接将其添加为本地 git 项目的来源，即该代码的存储位置；

git remote add origin \
https://github.com/fan-pengfei/bash_learning.git

远程备份代码：

typora图片上传出错

Tue, 17 Aug 2021 13:00:31 +0000

Typora问题记录；

图片上传出错问题解决办法：

1、名字重复 2、服务器端口出错 3、图床owner\repo填写出错

Windows10 Bat脚本

Tue, 17 Aug 2021 12:41:10 +0000

常用bat脚本；

Windows bat脚本：

依次执行多条命令，并且执行完执行完毕并不退出：

/*upload.bat:博客自动上传脚本*/
call hexo clean //
call hexo g //博客生成
call hexo d //博客上传
pause //页面暂停

同时执行多条命令，并且执行完执行完毕并不退出（以下例子仅仅说明语法，并不代表可用）：

/*upload.bat:博客自动上传脚本*/
start hexo clean //
start hexo g //博客生成
start hexo d //博客上传
pause //页面暂停

脚本运行结果：

Hexo+Yilia搭建自己的博客

Tue, 17 Aug 2021 07:19:40 +0000

搭建自己的博客；

缘起

一直想着要搭建一个属于自己的博客，感觉这样子很酷很酷，也是正好记录一下自己学习中遇到的问题，就当做一个笔记本来用吧！

原先想着用树莓派做服务器就可以搭建自己的的个人网站用来写博客，先在阿里云上购买了域名，其实最后是买了两个：

fan-pengfei.top
fan-pengfei.xyz

为啥买了两个呢？

波折

其实是我自己太粗心大意了，在二月份的时候自己就买了.xyz这一个域名，后来忙其他的事就把这件事搁置了；注册新域名的时候发现这个已经被注册了（没想到是自己之前注册的），所以没办法，只能感慨与自己同名同姓的人真多，然后就注册了.top域名;

注册完才发现，自己的域名控制台上竟然有两个域名，这才让我想起尘封已久的记忆，不过头一个快过期了，就用第二个搭建了这个个人网站；

https://fan-pengfei.top

前两天闲来无事，就又想折腾一下搭建自己博客的事；找了很多资料，终于还是将这个博客搭建起来了，挺简约的，自己很喜欢，毕竟博客就是用来记录自己学习到的知识，所以博客的内容应该更加重要。

步骤

一、配置Github

首先注册、登录： https://github.com/

记住自己的Username（很重要）；

然后右上角选择 Create a new repository；

Repository name ->填自己的名字, yourname.github.io->这个就是你博客的域名了(yourname与你的注册用户名一致)；

例如，我的域名是github.com/fan-pengfei，就填入fan-pengfei.github.io；

二、配置环境

安装 Node.js： https://nodejs.org/en/

安装 Git： https://github.com/waylau/git-for-win

安装完成后，在开始菜单里找到Git->Git Bash，打开，并依次执行以下命令：

git config --global user.name "username"
git config --global user.email "useremail"

其中名称和邮箱都是Github注册时自己的名字和邮箱；

安装 Hexo，所有必备的应用程序安装完成后，即可使用 npm 安装 Hexo:

npm install -g hexo-cli

至此环境安装完毕（推荐使用cmder，超级好用的）;

三、电脑设置

在电脑E盘（自己随意）目录下新建文件夹my_blog，进入my_blog，按住Shift键点击鼠标右键，选择Cmder Here；因为我有安装Cmder，没有安装的点击“在此处打开命令窗口”，输入：

hexo init blog

稍微等待下，速度有点慢，成功后将提示：

INFO  Start blogging with Hexo!

重新打开CMD，输入：

ssh-keygen -t rsa -C "Github的注册邮箱地址"

一路Enter过来就好，得到信息：

构建荔枝派zero完整系统以及运行QT程序

Tue, 17 Aug 2021 07:19:26 +0000

荔枝派使用记录；

我的第一个作品——小一

Sun, 16 Aug 2020 12:15:20 +0000

自从前几个月学了51单片机和stm32，我就一直想着做一个自己的作品，后来思来想去，就产生了做一个小型钟表的想法。既然是自己的作品，那么从设计电路板，到焊接电子元件，再到程序的编写，再到最后的调试和Debug，都应该是自己独立完成。想法有了，然后就开始动手制作。

因为之前在焊洞洞板的时候，发现精细的电路是很难用洞洞板焊接的，所以就开始在网上找资料学习画PCB电路板，刚开始是找的凡亿教育的视频来看，虽然讲的很好，但是好像不太适合我这种刚入门的小白，在我苦苦盯着视频研究了大半天却一脸懵之后，我最后决定还是自己摸索，不懂的，直接问度娘，不得不说，度娘真的帮了我好多。

然后又花了半天时间发现问题，解决问题，然后就突然什么都明白了，也理解了元件库，封装库，原理图和pcb文件之间的关系，也学会了自己画封装库和元件库，一切好像都是水到渠成。最后就又花了几天的时间绘制并打样了我的第一块电路板（不得不说，嘉立创的五元包邮的板子真的太香了）。

这个板子很简单，却为小一的诞生奠定了基础。

画了这个小核心板之后，就开始画小一了，因为需要先确定下所使用的芯片，所以在画板子之前，我开始选择所需要的芯片，最后决定主控芯片选择宏晶公司的stc15w408as，因为这个芯片小体积价格便宜却有着强大的功能，而且外围电路也极其简单。

考虑到我想要实现的功能，又选择了Ds1302时钟芯片，LM75a温度测量芯片，微型蜂鸣器，纽扣电池，以及实现程序下载的CH340G芯片。

画了很久才终于画出了pcb电路图，主要是布线和器件布局太麻烦，一动不动画了好几个下午，最后终于成功了，便把pcb文件发给嘉立创，几天后，元件和电路板几乎同时到了，让我很不开心的是，等我收到板子之后，才发现板子有很多的错误，比如开关选择的型号不对；电路板上丝印很不清晰，甚至都重合在一起，无法辨识；有些线还连接有错误，我很是沮丧，最后我只好用来练习焊接贴片元件，物尽其用。

然后就是修改原理图和pcb文件，然后把pcb文件又一次发个嘉立创，又过了几天，板子才到。我迫不及待的开始焊接，好难啊，即使我已经买了936焊台，但是因为我贴片元件焊接的经验实在是太少了，所以还是焊了好长的时间，最后终于焊好了，我在内心祈祷着，很怕电源一接通，就会短路，板子会烧掉。结果还好，电源指示灯成功点亮，然后就开始尝试下载程序，结果却是失败，最后又找了好久才发现问题所在。原因是我没有考虑到单片机下载程序时需要冷启动，最后又飞了好几根线，才终于下载成功。开心爆了！！！

然后又依次下载了一些测试程序，结果又发现了一些问题，比如走时不太准，纽扣电池掉电太快，又想了好久才解决这些问题。走时不准是因为我的手上有静电，会使走时受到干扰；纽扣电池掉电太快，是因为有一根线连错了，然后又飞了一根线，加了两个电容，然后终于可以了，可以实现所有的功能了。这些事情说着简单，其实真的很难，那些问题都太奇怪了，网上根本找不到资料，都是一点点试出来的，太难了。然后就是漫长的软件开发过程了，这可是比硬件更难的啊。

软件开发又花了好长的时间，写了好久，然后终于可以写好了，现在当然还是有一些bug，不过都是小问题，大概的已经OK了。程序加起来有好几千行，一个模块是一个C文件和H文件，模块化程序，可以让以后移植程序变得很方便。最后大概实现以下功能：

实时时钟（可以实现掉电不掉时）
温度测量（分辨率0.125℃，测量范围:-55℃～+125℃）
可设置闹钟（也可作为定时器，可设置的时间范 围:1s～24小时，到设定时间有蜂鸣器提醒）
秒表（最小精度1ms，可中途暂停，可清零）
电压表（范围:0～5V,精确度:10位精度AD转换）（改程序ing，因为有bug）

基本不可能有其他功能了，因为STC15W408AS只有8kflash,而现在的程序文件已经7.56k了，只能等以后换用更强大的芯片，才能有更多的功能了。演示视频我放在下面了，也算是比较成功吧，我还是超级满意的呀。

因为飞线很不美观，所以我打算升级小一，PCB电路图已经画好了，应该是不会再有前两版的那些错误了，而且加入了新的功能，比如可以用锂电池供电，给锂电池充电等功能。

哈哈，超开心，小一是我真正意义上的第一件作品，希望我以后会有更多的作品，小一会有更多的兄弟姐妹，也会升级小一，给他更强大的大脑，拥有更多的功能。

有兴趣的兄弟姐妹，可以跟我交流，我可以帮你们解决一些我力所能及的问题。

我的第一篇博客

Sun, 16 Aug 2020 04:56:20 +0000

上大学后，第一次接触到单片机和电路设计，我便觉得这将是我一生所爱。

从小学到初中，我一直都算是一个爱折腾的小孩子，对什么都特别的有兴趣，拆过很多东西，电器，玩具，不计其数。那时候，什么也不懂，就自己折腾着玩。

记得有一段时间，自己很想有一架自己的遥控飞机，刚开始就觉得有翅膀，有电机，就能飞起来，甚至还用塑料片子和泡沫做了一架原型，最后当然失败了，然后又自己用手机在网上搜索，才明白原来做一个遥控飞机是那么的复杂，要有舵机，起落架，能产生升力的机翼，还要有无刷电机，遥控装置，这些对于当时的我来说都是遥不可及的东西，最后这个做飞机的事情也不了了之了。

到了初三的时候，用仅有的钱在淘宝上买了无刷电机和电调，但是却无论如何无法让电机转起来，一直不知道是什么原因，后来就上网上找资料，最后发现是缺少一个控制的东西，然后就在淘宝买了一个舵机测试仪，最后终于转起来了，（直到不久前，我才明白舵机控制仪的原理，是通过旋钮，来控制输出一定占空比的脉冲，然后当做信号驱动电机或者舵机，用来控制电机转速，或者说舵机转动的角度，前几天我已经用单片机输出脉冲成功驱动我买到的舵机。）当时真的是激动极了，而且那无刷电机的转速超过我玩过的任何一个电机。当时拍的视频，现在还能找到。

后来有一段时间又迷上了土豆炮，是偶然间在网上看见的，然后就开始自己制作，原理很简单，就是在密闭容器内放入可燃气体，然后用电火花将气体点燃即可。燃料燃烧，气体膨胀，就会将填充的土豆发射出去，威力挺大。第一次做就做成功了，土豆炮弹的威力让我很是满意。后来改进了好多的版本，有迷你版本的，是用打火机做的，特别小巧，用花露水做为燃料，可以发射牙签或者火柴，也能飞个好几米。也有比较大的，可以发射干电池，用杀虫剂喷雾作为燃料，威力很大，近距离甚至可以打碎数厘米的瓦片，就是发射速度比较慢，因为燃料和炮弹都是手工装填，直到现在这个问题我也没有找到解决办法。

这些东西都很有意思，我在不懂任何电路知识的时候，甚至自己做过一个三极管自激电路，可以用来产生震荡，然后驱动变压器，或者一个超短距离的无线输电，当时根本不懂为什么，只是按照网上的接线方法，找一些相似的元件，然后连接起来就可以了，成功当然会让我很开心，失败也不会让我很沮丧，只是觉得好玩罢了。可能实践有助于知识的掌握理解，前些天我学习三极管的知识的时候，很快就能理解三极管的原理和应用。

在初中的时候，因为是留级生，学习压力很小很小，然后就开始做了很多的小手枪，有用橡皮筋作为动力的，有用弹簧作为动力的，甚至还有一个用磁铁作为动力的。当时我的想法真的是天马行空，好多好多奇奇怪怪的想法。因为有时候会拆很多东西，不懂的就查资料，也学得了很多奇奇怪怪的知识，比如饮水机里的制冷片，对的，饮水机制冷的原理跟冰箱完全不同，饮水机用的是半导体制冷片，只要通电，就能一面发热，一面制冷，特别神奇。而且可以根据温差发电，这些我都验证过，真的是太神奇了。还有什么焦耳小偷，ZVS电路，斯特林发动机等等，可能我后来对电子一类的感兴趣就跟这有很大的关系吧，因为这些东西真的有趣。

因为爱折腾，也做过好多傻事，比如我知道502的味道，有点甜，知道花露水的味道，很上头；在有一次做水火箭的时候，压力过大，然后瓶盖被崩出来，正对着我的脑门来了一下，肿了好几天。胳膊被烧过好几次，汗毛烧了又长，长了又烧，可能也习惯了，头发也被烧过两次，还好最后都长回来了。

上了大学，学了自动化这个专业，好像跟我的兴趣挺符合的，又入了单片机这个坑，感觉很棒，兴趣能成为工作当然是很棒的一件事。

这是我的第一篇文章，以后，我会写一些我学习的过程，以及学习中的一些问题和思考，会一直写的，因为一直在学习。

Rancho's Notes

一转四USB转TTL模块

原理图

PCB

在线BOM

实物图

LOG分级打印

环境

printf映射

windows11下uboot烧录

buildroot的OVERRIDE_SRCDIR机制

全志H3开发

Uboot开发

环境搭建

Uboot编译

Uboot烧录

上电测试

Linux内核开发

源码下载

编译

我的大学四年

神奇的Jeff Dean

C语言实现交换二进制数的任意两位

基于esp32的手表

硬件

原理图

PCB

在线BOM

实物图

Kicad生成Gerber文件

PID进阶教程

PID的开始

基于Arduino的LVGL移植

软件版本

工程配置

库安装

配置文件

lv_conf.h

lv_demo_conf.h

自定义显示接口和外部输入接口

文件添加

代码内容

TODO

记得翻译一下这篇文章

ESP32-PICO-D4开发记录

Pico D4介绍

原理图设计

原理图设计参考

重启问题

0x01 0x01 芯片上电复位 系统复位

docker初尝试

docker常用命令

使用C和C++进行混合编程

环境说明

源码编写

头文件：

源文件：

ROS相关知识

工作空间构建

自定义包

编译功能包

在GDB下调试STM32的记录

一、调试步骤：

准备工作

1、启动Jlink GDB Server

2、GDB调试

3、需要注意的地方

二、常用命令

1、p(打印)

2、s(单步运行)

3、l(列出)

4、watch(变量监视)

基于STM32的CMAKE模板

CMAKE学习记录

STM32启动代码原理分析

简述

源码分析

部分解释

STM32的启动过程

1、函数的调用过程：

0x01 0x01 芯片上电复位系统复位

第七章链接