在提升网站的SEO表现时，使用Baidu分析工具可以帮助您更好地理解用户行为并优化网站。然而，要使这一切顺利进行，您需要获取并正确配置Baidu分析ID。下面我将一步步讲解如何获取Baidu分析ID并将其添加到您的服务器上。




### 1. 注册或登录百度统计账号

首先，您需要访问[百度统计官网](https://tongji.baidu.com/)，并使用您的百度账号进行登录。如果您还没有账号，可以快速注册一个。登录后，您就可以开始管理您的网站项目。

### 2. 创建新的网站项目

登录后，导航到“管理”部分，然后点击“添加网站”。按照提示填写您的网站信息，包括网站名称、URL、行业等内容。填写完毕后，点击保存，系统会为您生成一段用于网站统计的代码。

### 3. 获取百度统计代码

成功添加网站后，百度统计系统会生成一段统计代码。这段代码包含了您的Baidu分析ID，通常是以`hm.baidu.com/h.js%3F`开头，后面跟随一串数字和字母。

例如，您可能会得到如下代码：
```html
<script>
var _hmt = _hmt || [];
(function() {
  var hm = document.createElement("script");
  hm.src = "https://hm.baidu.com/hm.js?9f52487dbcaf597ff3732d3a160467c";
  var s = document.getElementsByTagName("script")[0]; 
  s.parentNode.insertBefore(hm, s);
})();
</script>
```
在这段代码中，您的Baidu分析ID是`9f52487dbcaf597ff3732d3a160467c`。这个ID在百度统计系统中唯一标识您的网站项目，用于数据的收集和分析。

### 4. 将百度统计代码添加到您的服务器

接下来，您需要将这段代码添加到您的网站上。具体来说，您应该将代码粘贴到每个网页的`<head>`标签内。确保每次页面加载时，这段代码都能被正确加载。这样，百度统计就可以跟踪到用户的所有行为。

### 5. 验证和优化

代码部署后，您可以通过百度统计后台查看数据是否被成功采集。如果数据开始呈现，说明Baidu分析ID已正确部署。您还可以根据数据表现来不断优化SEO策略，从而提升网站的搜索引擎排名。

我的网站是否加入SEO，手动检查代码的方法：
https://tongji.baidu.com/web/help/article?id=93&type=0

### 总结

获取并正确配置Baidu分析ID对于提升网站的SEO表现至关重要。通过注册百度统计账号、创建网站项目、获取统计代码并将其添加到网站，您可以轻松实现这一目标。记得定期查看统计数据，并根据分析结果进行持续优化。

如何获取并使用Baidu分析ID提升SEO效果

黑客是很疯狂的，只要能登录你的服务器，就可以窃取你的数据，然后用数据要挟你给钱，我的服务器一晚上被尝试这么多次：




Last failed login: Thu Aug 29 20:25:51 EDT 2024 from 39.155.215.179 on ssh:notty
There were 1827 failed login attempts since the last successful login.
Last login: Thu Aug 29 10:02:13 2024 from 120.244.236.133

如图：
![image.png](/static/img/520fd4d352efdeb60dfe47926817d13f.image.webp)


为了有效防止黑客，就一定要保护好自己打开的端口。用ss -tuln指令查看自己打开了哪些端口，如下图，可以看到我的80、443、22都是打开的。


![image.png](/static/img/3cc6037722c3a0fac9c5b06e87d9a3bf.image.webp)

网站服务的80和443端口，用Docker启动，要以非root用户的身份运行Docker容器，可以在Dockerfile中创建和使用非root用户，或者在启动容器时指定用户。这一点不强求，毕竟很多东西是需要Docker里也是root的。

宿主机ssh登录的22端口，这个端口非常重要了，一定要保护好。保护措施：

为了保护你的服务器的22端口SSH登录，你可以采取以下措施：

1. **使用强密码或SSH密钥认证**：
   - 确保所有用户使用强密码登录，或更好的是，禁用密码登录，使用SSH密钥认证。SSH密钥认证更安全，不容易被暴力破解。

这里介绍ssh密钥对登录，目前我采用的也是如此方式，首先在服务器执行：
ssh-keygen -t rsa -b 4096 -C "742971636@qq.com"
生成了密钥对。

把私钥文件/root/.ssh/id_rsa下载到windows本地C:\Users\Administrator\moba_ssh_rsa\id_rsa。确保私钥文件的安全性，不要泄露给他人。服务器的私钥可以删除掉。

本地可以用指令连接服务器：ssh -i C:\Users\Administrator\moba_ssh_rsa\id_rsa user@your_server_ip

或者用 mobaxterm 连接服务器，打开mobaxterm，如下图，使用密钥对登录：

![image.png](/static/img/a721b1aa5f658947164ee3dee7dd6099.image.webp)



2. **更改默认SSH端口**：
   - 将SSH服务的默认端口22更改为一个非标准端口，这可以减少被攻击的机会。

   具体步骤：
   - 编辑`/etc/ssh/sshd_config`文件，找到`Port 22`行并将其更改为一个非标准端口，例如`Port 2222`。
   - 重启SSH服务：`sudo systemctl restart sshd`

如下图：

![image.png](/static/img/1bf1009e551313450d4835f3994d4582.image.webp)



3. **使用防火墙限制访问**：
   - 使用防火墙如`ufw`或`iptables`限制对SSH端口的访问，仅允许特定IP地址访问。

   具体步骤（使用ufw为例）：
   - 允许特定IP访问SSH：`sudo ufw allow from <your_ip> to any port 22`
   - 如果更改了端口，允许新端口：`sudo ufw allow <new_port>`
   - 启用ufw：`sudo ufw enable`


4. **启用Fail2Ban防止暴力破解**：
   - 安装并配置Fail2Ban，它会监控登录失败的尝试，并在多次失败后自动封锁可疑IP。

   具体步骤：
   - 安装Fail2Ban：`sudo apt install fail2ban`
   - 配置Fail2Ban：编辑`/etc/fail2ban/jail.local`，添加如下配置：
     ```ini
     [sshd]
     enabled = true
     port = 22
     filter = sshd
     logpath = /var/log/auth.log
     maxretry = 3
     bantime = 3600
     ```
   - 重启Fail2Ban：`sudo systemctl restart fail2ban`


5. **禁用Root用户SSH登录**：
   - 禁用root用户直接通过SSH登录，增加安全性。

   具体步骤：
   - 编辑`/etc/ssh/sshd_config`文件，找到`PermitRootLogin`行，并将其更改为`no`。
   - 重启SSH服务：`sudo systemctl restart sshd`

通过以上步骤，你可以显著提高SSH服务的安全性，减少被攻击的风险。

【建站】网络安防，如何有效保护你的服务器

使用selenium模拟浏览器行为，免得导出自己的文章还要一篇一篇点击。



下载：

https://googlechromelabs.github.io/chrome-for-testing/


![image.png](/static/img/d42f43141a5e21b787d6c31db402aaac.image.webp)

python3.10以上，安装：


```bash
pip install selenium
```

在最后一句话打断点登录到博客管理页面。

```python
# encoding: utf-8
import time
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
import json

# 创建ChromeOptions对象
chrome_options = Options()
# chrome_options.add_argument("--headless")  # 启动无头模式
chrome_options.add_argument("--disable-gpu")

# 创建Service对象
service = Service(executable_path='chromedriver.exe')

# 创建WebDriver对象并启动浏览器
driver = webdriver.Chrome(options=chrome_options, service=service)

# 访问网页
driver.get("https://mp.csdn.net/mp_blog/manage/article?spm=3001.5298")

# 关闭浏览器
driver.quit()

```

手动在断点期间执行这个代码可以保留下来某个页面下的所有博客信息。

```python
all_blogs = []
pagex = 5
for page in range(1, pagex + 1):
    # 获取当前页面的博客数量（注意最后一页可能少于20个）
    blogs_on_page = driver.find_elements(By.XPATH,
                                         '//*[@id="view-containe"]/div/div/div[3]/div[2]/div/div[1]/div[1]/p[1]/a')
    for i, blog in enumerate(blogs_on_page, start=1):
        try:
            blog_xpath = f'//*[@id="view-containe"]/div/div/div[3]/div[2]/div[{i}]/div[1]/div[1]/p[1]/a'
            blog_name = driver.find_element(By.XPATH, blog_xpath).text
            blog_link = driver.find_element(By.XPATH, blog_xpath).get_attribute('href')
            all_blogs.append({"name": blog_name, "link": blog_link})
        except Exception as e:
            print(f"Error extracting blog on page {page}, index {i}: {e}")
    if page < pagex:
        try:
            driver.find_element(By.CLASS_NAME, "btn-next").click()
            time.sleep(2)
        except Exception as e:
            print(f"Error navigating to page {page + 1}: {e}")
            break
with open('caogaoxiang.json', 'w', encoding='utf-8') as f:
    json.dump(all_blogs, f, ensure_ascii=False, indent=4)
```

有了json信息后，依靠这个代码可以拿到自己的博客原始内容：


```python
with open('all_blogs.json', 'r', encoding='utf-8') as f:
    blogs = json.load(f)
for index, blog in enumerate(blogs, start=1):
    file_name = f"output/{index:03}.md"
    if os.path.exists(file_name):
        continue
    try:
        driver.get(blog['link'])
        time.sleep(1)
        markdown_element = driver.find_element(By.XPATH, '/html/body/div[1]/div[1]/div[2]/div/div[2]/div[1]')
        markdown_content = markdown_element.text
        with open(file_name, 'w', encoding='utf-8') as f:
            f.write(markdown_content)
        print(f"成功保存 {blog['name']} 到 {file_name}")
    except Exception as e:
        print(f"处理 {blog['name']} 时出错: {e}")
```

通过这个代码可以拿到自己博客的所有图片：


```python

import os
import re
import uuid
import requests
import markdown
from bs4 import BeautifulSoup
from urllib.parse import urlparse


# 创建一个函数来解析Markdown文件，下载图片并更新链接
def process_markdown_file(md_file, output_dir, img_cntx, dst_md):
    with open(md_file, 'r', encoding='utf-8') as f:
        markdown_content = f.read()

    # 将Markdown解析为HTML
    html = markdown.markdown(markdown_content)

    # 使用BeautifulSoup解析HTML以查找图片标签
    soup = BeautifulSoup(html, 'html.parser')
    images = soup.find_all('img')

    # 初始化一个字典来存储旧链接和新链接的映射
    img_url_mapping = {}

    # 自定义请求头来伪装为浏览器
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'
    }
    # 遍历所有的图片标签并处理
    for img in images:
        img_url = img['src']

        try:
            # 获取图片扩展名
            parsed_url = urlparse(img_url)
            img_extension = os.path.splitext(parsed_url.path)[-1]

            # img_extension不是png jpg jpeg gif webp就

            # 生成UUID作为图片文件名
            img_name = f'{img_cntx:05d}{img_extension}'
            img_cntx += 1
            img_path = os.path.join(output_dir, img_name)

            if os.path.exists(img_path):
                img_url_mapping[img_url] = img_path
            else:
                # 下载图片
                img_data = requests.get(img_url, headers=headers).content
                # 保存图片到本地
                with open(img_path, 'wb') as img_file:
                    img_file.write(img_data)

                # 更新链接映射
                img_url_mapping[img_url] = img_path

            # print(f"成功下载图片 {img_url} 并保存为 {img_path}")
        except Exception as e:
            print(f"下载图片 {img_url} 时出错: {e}")

    # 从文件中读取正则表达式
    with open('pat.txt', 'r', encoding='utf-8') as file:
        pattern_str = file.read()

    # 编译正则表达式
    pattern = re.compile(pattern_str)

    # 替换Markdown中的图片URL
    for old_url, new_path in img_url_mapping.items():
        # 将路径中的反斜杠替换为正斜杠
        corrected_path = new_path.replace("\\", "/")
        # 使用编译后的正则表达式进行替换
        # markdown_content = pattern.sub(r'![image](' + corrected_path + r')', markdown_content)
        corrected_path = "/" + corrected_path
        markdown_content = markdown_content.replace(old_url, corrected_path)

    # 将更新后的Markdown内容保存回文件
    with open(dst_md, 'w', encoding='utf-8') as f:
        f.write(markdown_content)

    # print(f"更新后的Markdown文件已保存为 {dst_md}")

    return img_cntx


if __name__ == '__main__':
    img_cnt = 1
    srcp = "output"
    files = os.listdir(srcp)
    dst = "output_mdwebsite"
    os.makedirs(dst, exist_ok=True)
    output_dir = 'static/img/images'  # 替换为你希望保存图片的文件夹
    os.makedirs(output_dir, exist_ok=True)
    for md_file in files:
        try:
            dst_md = os.path.join(dst, md_file)
            md_file = os.path.join(srcp, md_file)
            img_cnt = process_markdown_file(md_file, output_dir, img_cnt, dst_md)
        except:
            print(md_file)

```

用这个代码取出所有tags：


```python
# encoding: utf-8
import time

from bs4 import BeautifulSoup
from fontTools.misc.psOperators import ps_string
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
import json
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 创建ChromeOptions对象
chrome_options = Options()
# chrome_options.add_argument("--headless")  # 启动无头模式
chrome_options.add_argument("--disable-gpu")

# 创建Service对象
service = Service(executable_path='chromedriver.exe')

# 创建WebDriver对象并启动浏览器
driver = webdriver.Chrome(options=chrome_options, service=service)

# 访问网页
driver.get("https://mp.csdn.net/mp_blog/manage/article?spm=3001.5298")

# 打开all_blogs2.json文件并加载数据
with open('all_blogs2.json', 'r', encoding='utf-8') as f:
    all_blogs = json.load(f)

# 定义等待条件
wait = WebDriverWait(driver, 10)  # 设置最长等待时间为10秒


for blogdata in all_blogs:
    name = blogdata['name']
    link = blogdata['link']
    # 提取出文章ID
    get_qianzhui = "https://qq742971636.blog.csdn.net/article/details/"
    articleId = link.replace("https://editor.csdn.net/md/?articleId=", "")
    link = get_qianzhui + articleId
    blogdata['link'] = link

    # 等待元素加载
    try:
        driver.get(link)
        time.sleep(1)

        cls_name = 'blog-tags-box'

        # 等待直到指定的元素可见
        element = wait.until(EC.visibility_of_element_located((By.CLASS_NAME, cls_name)))

        elements = driver.find_elements(By.CLASS_NAME, cls_name)
        html_contents = [element.get_attribute('outerHTML') for element in elements]
        html_content = ''.join(html_contents)
        soup = BeautifulSoup(html_content, 'lxml')
        category_links = soup.select('.tags-box .label + a')
        categories = [link.text.strip() for link in category_links]
        tag_links = soup.select('.tags-box a[rel="nofollow"]')
        tags = [link.text.strip() for link in tag_links]
        blogdata['categories'] = categories
        blogdata['tags'] = tags
    except:
        print(f"Error extracting categories for blog: {name}")

    try:
        cls_name = 'time'
        time_element = driver.find_element(By.CLASS_NAME, cls_name)
        time_text = time_element.text
        blogdata['time'] = time_text
    except:
        print(f"Error extracting time for blog: {name}")

# 将所有数据保存到一个JSON文件中
with open('all_blogs3.json', 'w', encoding='utf-8') as f:
    json.dump(all_blogs, f, ensure_ascii=False, indent=4)

# 关闭浏览器
driver.quit()

```


最终用这个代码进行传输博客到自己服务器：


```python
import json
import os

import re
import time
from datetime import datetime, timezone, timedelta
import requests


def adjust_markdown_line_breaks(input_file, output_file):
    with open(input_file, 'r', encoding='utf-8') as file:
        content = file.read()

    # 使用正则表达式替换不在代码块中的单个换行符为双换行符
    adjusted_content = re.sub(r'(?<!\n)\n(?!\n|```)', '\n\n', content)

    with open(output_file, 'w', encoding='utf-8') as file:
        file.write(adjusted_content)


# chuli_wenzhang = './danpianji.json'
# categoriesx = '单片机ban'

# chuli_wenzhang = './shenduxuexi.json'
# categoriesx = '深度学习ban'

# chuli_wenzhang = './linuxyunwei.json'
# categoriesx = 'Linux运维'

chuli_wenzhang = './taobaozuopin.json'
categoriesx = '售卖作品'

jinwokejian_wenzhang = 'jinwokejian.json'
caogaoxiang_wenzhang = 'caogaoxiang.json'
all_wenzhang_xinxi = "all_blogs3.json"

src = r"C:\Users\Administrator\Downloads\csdn-blog-export-main"
src_md_path = r"C:\Users\Administrator\Downloads\csdn-blog-export-main\output_mdwebsite"

dst_md = r"C:\Users\Administrator\Downloads\csdn-blog-export-main\md"
os.makedirs(dst_md, exist_ok=True)

with open(chuli_wenzhang, 'r', encoding='utf-8') as f:
    linuxyunwei_data = json.load(f)

with open(jinwokejian_wenzhang, 'r', encoding='utf-8') as f:
    jinwokejian_data = json.load(f)

with open(caogaoxiang_wenzhang, 'r', encoding='utf-8') as f:
    caogaoxiang_data = json.load(f)

with open(all_wenzhang_xinxi, 'r', encoding='utf-8') as f:
    all_blogs = json.load(f)

# 用文章id做key，文章信息做value，all_blogs
all_blogs_dict = {}
for index, blog_dict in enumerate(all_blogs):
    blog_dict['index'] = index + 1
    id = blog_dict['link'].replace('https://qq742971636.blog.csdn.net/article/details/', '')
    if id in all_blogs_dict:
        print('id重复', id)
    all_blogs_dict[id] = blog_dict

# 仅我可见的文章要从chuli_wenzhang删除，先整上id
chuli_wenzhang_dict = {}
for blog_dict in linuxyunwei_data:
    id = blog_dict['link'].replace('https://editor.csdn.net/md/?articleId=', '')
    chuli_wenzhang_dict[id] = blog_dict

# jinwokejian_wenzhang
jinwokejian_wenzhang_dict = {}
for blog_dict in jinwokejian_data:
    id = blog_dict['link'].replace('https://editor.csdn.net/md/?articleId=', '')
    jinwokejian_wenzhang_dict[id] = blog_dict

# caogaoxiang
caogaoxiang_wenzhang_dict = {}
for blog_dict in caogaoxiang_data:
    id = blog_dict['link'].replace('https://editor.csdn.net/md/?articleId=', '')
    caogaoxiang_wenzhang_dict[id] = blog_dict

# 删除chuli_wenzhang_dict中的仅我可见的文章
for id in jinwokejian_wenzhang_dict:
    if id in chuli_wenzhang_dict:
        del chuli_wenzhang_dict[id]
        print('删除了', id)

# 删除chuli_wenzhang_dict中的草稿文章
for id in caogaoxiang_wenzhang_dict:
    if id in chuli_wenzhang_dict:
        del chuli_wenzhang_dict[id]
        print('删除了', id)

# 用id读取md文件，然后写入到dst_md
for id in chuli_wenzhang_dict:
    blog_dict = all_blogs_dict[id]
    name = blog_dict['name']
    index = blog_dict['index']
    src_md_file = os.path.join(src_md_path, f'{index:03}.md')
    dst_md_file = os.path.join(dst_md, f'{index:03}.md')
    adjust_markdown_line_breaks(src_md_file, dst_md_file)


def remove_first_newline(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith(".md"):
            file_path = os.path.join(directory, filename)
            with open(file_path, 'r', encoding='utf-8') as file:
                lines = file.readlines()

            # 如果第一行是空行，移除它
            if lines and lines[0].strip() == '':
                lines.pop(0)
                print(f'Removed first newline in {file_path}')

            # 重新写入文件
            with open(file_path, 'w', encoding='utf-8') as file:
                file.writelines(lines)


for i in range(6):
    # 调用函数，传入你的md文件所在的目录路径
    remove_first_newline(dst_md)

import os


def add_prefix_if_codeblock(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith(".md"):
            file_path = os.path.join(directory, filename)
            with open(file_path, 'r', encoding='utf-8') as file:
                lines = file.readlines()

            # 检查文件是否以```开头
            if lines and lines[0].strip().startswith("```"):
                # 在文件开头添加"运维信息："
                lines.insert(0, chuli_wenzhang)
                print(f'Added prefix in {file_path}')

            # 重新写入文件
            with open(file_path, 'w', encoding='utf-8') as file:
                file.writelines(lines)


# 调用函数，传入你的md文件所在的目录路径
add_prefix_if_codeblock(dst_md)


def add_more_marker(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith(".md"):
            file_path = os.path.join(directory, filename)
            with open(file_path, 'r', encoding='utf-8') as file:
                lines = file.readlines()

            # 检查文件中是否含有
            if "" not in "".join(lines):
                # 如果第一行后不存在，插入在第二行
                lines.insert(1, "\n\n\n\n")

            # 重新写入文件
            with open(file_path, 'w', encoding='utf-8') as file:
                file.writelines(lines)


# 调用函数，传入你的md文件所在的目录路径
add_more_marker(dst_md)

import os
import re


def remove_blank_lines_in_code_blocks(md_content):
    # 正则表达式匹配代码块
    code_block_pattern = r'(```[\s\S]*?```)'  # 匹配以 ``` 开始和结束的代码块

    def remove_blank_lines(match):
        # 获取匹配的代码块内容
        code_block = match.group(0)
        # 去掉代码块中的空行
        code_block = re.sub(r'\n\s*\n', '\n', code_block)
        return code_block

    # 使用sub方法替换代码块中的内容
    modified_content = re.sub(code_block_pattern, remove_blank_lines, md_content)

    return modified_content


def process_md_files_in_directory(directory):
    # 遍历指定目录下的所有文件
    for filename in os.listdir(directory):
        if filename.endswith('.md'):
            filepath = os.path.join(directory, filename)
            # 读取Markdown文件内容
            with open(filepath, 'r', encoding='utf-8') as file:
                content = file.read()

            # 去掉代码块中的空行
            modified_content = remove_blank_lines_in_code_blocks(content)

            # 将修改后的内容写回原文件
            with open(filepath, 'w', encoding='utf-8') as file:
                file.write(modified_content)

            print(f"已处理文件: {filename}")


# 处理目录下的所有Markdown文件
process_md_files_in_directory(dst_md)

chuli_wenzhang_dict_rev = []
for id in chuli_wenzhang_dict:
    chuli_wenzhang_dict_rev.append(id)
chuli_wenzhang_dict_rev = chuli_wenzhang_dict_rev[::-1]

jiezhe = "139426685"

lueguo = True
# 将chuli_wenzhang_dict上传到api
for id in chuli_wenzhang_dict_rev:
    if jiezhe == id:
        lueguo = False
    if lueguo is True:
        continue
    print("=======================================")
    print(id)
    blog_dict = all_blogs_dict[id]
    name = blog_dict['name']
    link = blog_dict['link']

    categories = blog_dict['categories']
    tags = blog_dict['tags']
    original_time_str = blog_dict['time']
    index = blog_dict['index']

    categories = 'OpenCV'
    tags = list(set(tags))

    original_time_str = re.sub(r'[\u4e00-\u9fff]', '', original_time_str)
    # 将字符串转换为 datetime 对象，并设定为中国时间（UTC+8）
    dt = datetime.strptime(original_time_str.strip(), '%Y-%m-%d %H:%M:%S')
    dt = dt.replace(tzinfo=timezone(timedelta(hours=8)))
    # 转换为 UTC 时间
    utc_dt = dt.astimezone(timezone.utc)
    # 转换为 ISO 8601 格式字符串，带毫秒和Z时区标志
    iso_time_str = utc_dt.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'

    # md
    md_filename = f"{index:03d}.md"
    md_filepath = os.path.join(dst_md, md_filename)
    content = open(md_filepath, 'r', encoding='utf-8').read()

    a = 1

    # API 端点
    url = "http://19.31.11.10/api/admin/article"

    # 设置请求头
    headers = {
        "accept": "application/json",
        "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyIsImlhdCI6MTcyNTE1NzI1MCwiZXhwIjo0ODc4NzU3MjUwfQ.",
        "Content-Type": "application/json"
    }

    # 请求体
    data = {
        "title": name,
        # "hidden": False,
        # "private": False,
        "content": content,
        "tags": tags,
        "category": categoriesx,
        # "updatedAt": iso_time_str,
        # "createdAt": iso_time_str,
    }

    max_attempts = 3  # 最大尝试次数
    attempt = 0
    while attempt < max_attempts:
        attempt += 1
        response = requests.post(url, headers=headers, json=data)

        if response.status_code == 201:
            print("Article published successfully.")
            break  # 请求成功，跳出循环
        else:
            print(f"Attempt {attempt}: Failed to publish article. Status code: {response.status_code}")
            if attempt < max_attempts:
                print("Retrying...")
                time.sleep(1)  # 等待2秒后重试（你可以根据需要调整等待时间）
    else:
        print("Failed to publish article after 3 attempts.")

print(len(chuli_wenzhang_dict))

```

【建站】如何把自己CSDN博客导出到本地markdown文件，导出所有博客

对于PIC16F1719单片机，没有直接的EEPROM，而是使用高耐久度的程序闪存（PFM）作为非易失性数据存储区域。这个区域特别适合存储那些需要频繁更新的数据。读写这个内存区域需要操作一些特殊功能寄存器，比如用于地址的`PMADRH:PMADRL`和用于数据的`PMDATH:PMDATL`。




执行从闪存中读取数据的操作步骤如下：
1. 将目标地址写入`PMADRH:PMADRL`寄存器对。
2. 清除`PMCON1`寄存器的`CFGS`位。
3. 设置`PMCON1`寄存器的`RD`控制位以启动读取操作。读取的数据将存储在`PMDATH:PMDATL`寄存器对中。

要将数据写入闪存，可以按照以下步骤进行：
1. 将目标闪存地址加载到`PMADRH:PMADRL`寄存器中。
2. 将数据写入`PMDATH:PMDATL`寄存器中。
3. 通过向`PMCON2`寄存器写入特定的值（先`55h`，再`AAh`）来执行解锁序列。
4. 设置`PMCON1`寄存器中的`WR`位以启动写操作。

这种操作过程确保了对非易失性内存的安全控制，用于存储关键数据。


高耐久度的程序闪存（PFM）是Microchip的PIC16(L)F1717/8/9系列微控制器中的一项存储技术，用于频繁更新的数据存储。根据提供的文档，这种高耐久度的程序闪存具有以下特性：

1. **容量大小**：
   - 对于PIC16(L)F1717微控制器，PFM的容量为128字节。
   - 对于PIC16(L)F1718/9微控制器，PFM的容量同样为128字节。

2. **高耐久度**：
   - 这种闪存支持高达100,000次的擦写循环，非常适合需要频繁更新的非易失性数据存储。

3. **地址范围**：
   - PIC16(L)F1717的高耐久度闪存地址范围为1F80h到1FFFh。
   - PIC16(L)F1718/9的高耐久度闪存地址范围为3F80h到3FFFh。

4. **应用**：
   - 高耐久度的程序闪存特别适合用于嵌入式系统中需要频繁更新的数据，如配置参数、运行计数器等。

这种PFM在设计上旨在代替传统的EEPROM，提供了更高的耐久性和更快的访问速度。对于一些嵌入式应用来说，它是一种高效且可靠的存储解决方案。

![image.png](/static/img/2df94ceed7822649689522ebc3142060.image.webp)


所以，写代码：

![image.png](/static/img/057ed059bb20996b9044429f595d824f.image.webp)

可以看到显示出了我写入的2345：

![image.png](/static/img/ef4e98c7c501a1b160d1faf3647e43c0.image.webp)

code：

```clike
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

讲解视频：

```clike
通过网盘分享的文件：2024-08-24 21-57-51.mkv
链接：https://pan.baidu.com/s/1ANlzKzfK70K93OQfueNE0w?pwd=tbsp 
提取码：tbsp 
```

【TB作品】PIC16F1719单片机，EEPROM，PFM，读写，PIC16F1718/19

一、	万年历
任务要求：
制作一个万年历，具有显示时间、日期、温度、湿度、闹钟功能。
1、OLED显示屏上显示日期和时钟（显示到秒，时间可走动）；（20分）
2、通过开发板上的温度传感器采集当前环境温度并显示在显示屏上；（20分）
3、通过湿度传感器采集当前环境湿度并显示在显示屏上；（20分）
4、通过独立按键设置闹钟，并在OLED上显示设置的闹钟时间，到达闹钟时间时蜂鸣器发出声响并持续一段时间，同时D1~D8以流水灯形式亮起；（20分）
5、日期为滚动特效；（20分）




附加题：
1、可以通过按键修改日期和时间（类似于手动调电子手表时间一样）。

【注释】
1、湿度传感器(需要领取）需要根据其使用手册和单片机原理图，由学生接到开发板上并编写湿度采集函数，更多湿度传感器信息请参考说明书或网络资料；
2、温度传感器DS18B20已焊接在手柄板上，其引脚连接查看手柄板原理图；
基本任务中，设置闹钟时，使用按键A4进行时间的上调，使用按键A5进行时间的下调，步进值为10s，即每按一次按键时间上调或下调10s。上调达到60s时，时间“分”加1；时间下调小于0s时，时间“分”减1，时间“时”的调节依此类推。
3、附加任务中，通过按键A1进行日期、时间、闹钟设置功能的切换，按键A4、A5仍为上调和下调按键，设置时间和闹钟时调节对象是“秒”，步进值为10s；设置日期时调节的对象是“日”，步进值是1日，大于一个月的最大日时，月份自动加一。


![image.png](/static/img/121e38eeeb26580365dd5bcc469203a2.image.webp)


![image.png](/static/img/b785bffbd72ee8fb4bb2e73ff701c64a.image.webp)


![image.png](/static/img/948b3580d0d4acdd0ca886659a51ff6a.image.webp)



在嵌入式系统的世界里，单片机的应用几乎无处不在。今天，我将与大家分享一个利用单片机制作的万年历项目，它不仅是一个时间日期的显示工具，还具有温度、湿度显示，以及闹钟功能。通过这个项目，你将了解到如何在单片机上实现这些常见的功能。



### 技术细节

#### 1. OLED 显示屏控制
项目中使用了128x64的OLED显示屏，用来显示时间、日期、温湿度等信息。通过编写相应的驱动代码，OLED显示屏可以完美地展示这些内容。显示时间与日期的功能利用了单片机的定时器来更新显示，实现了动态的秒表功能。

```c
void UpdateDisplay(void) {
    // 显示当前时间
    sprintf(displayBuffer, "Time:%02d:%02d:%02d", nowTime.hour, nowTime.minute, nowTime.second);
    OLED_ShowString(0, 2, displayBuffer, 16, 1);

    // 显示温湿度
    if (sensorStatusOK) {
        sprintf(displayBuffer, "R:%02d%% T:%02d.%dC", humidityDataHigh, temperature / 10, temperature % 10);
        OLED_ShowString(0, 4, displayBuffer, 16, 1);
    }
}
```

#### 2. 温度与湿度采集
项目使用了两种传感器来分别获取温度和湿度。DS18B20用于温度采集，DHT11用于湿度采集。通过对传感器的初始化与数据读取，成功将实时数据展示在OLED显示屏上。

```c
unsigned int GetTemperature(void) {
    unsigned int temp = 0;
    DS18B20_Init();
    DS18B20_WriteByte(SKIP_ROM);
    DS18B20_WriteByte(CONVERT_TEMP);
    temp = DS18B20_ReadByte() + (DS18B20_ReadByte() << 8);
    return (int)(temp * 0.0625 * 10); // 返回实际温度值
}
```

#### 3. 闹钟功能
在这个项目中，闹钟功能是一个亮点。当设定的时间到达时，蜂鸣器响起，LED灯以流水形式点亮，为提醒功能增添了视觉和听觉的双重效果。使用了简单的按键交互来设置闹钟时间，极大地方便了用户。

```c
void HandleAlarm(void) {
    if (nowTime.hour == alarmTime.hour && nowTime.minute == alarmTime.minute && nowTime.second == alarmTime.second) {
        TriggerAlarmBeep();
    }
}
```

#### 4. 用户交互
项目实现了通过按键的方式来调整时间、日期以及设置闹钟。这个功能模拟了电子手表的操作体验，用户可以通过不同的按键来切换设置模式并进行时间的上调或下调操作。

```c
void ProcessKeyInput(int key) {
    if (key == 7) {  // 上调时间或日期
        nowTime.second += 10;
        // 处理分钟、小时、日期的自动进位
        UpdateDisplay();
    }
}
```


### 实验报告：万年历项目

#### 一、实验目的

本实验旨在通过单片机开发制作一个具有多功能的万年历系统，包括显示时间、日期、温度、湿度和闹钟功能。通过完成此项目，学生将能够掌握基本的单片机编程技术、传感器数据采集、OLED显示屏控制以及闹钟功能的实现。

#### 二、实验原理

万年历项目的核心是通过单片机采集时间、日期、温度和湿度信息，并在OLED显示屏上进行实时显示。通过使用按键可以设置时间、日期和闹钟，当时间到达设定的闹钟时间时，蜂鸣器将发出警报声，并通过流水灯形式提示用户。

项目的关键模块包括：

1. **时间和日期管理**：通过定时器中断更新时间和日期，并通过算法计算当前的星期。
2. **温度和湿度采集**：使用DS18B20温度传感器和DHT11湿度传感器采集环境数据。
3. **OLED显示屏控制**：通过SPI通信接口向OLED发送数据，显示当前的时间、日期、温度和湿度。
4. **闹钟功能**：用户可以通过按键设置闹钟时间，闹钟到时蜂鸣器发声提示并通过LED流水灯进行视觉提示。

#### 三、实验设备

- MSP430单片机开发板
- DS18B20温度传感器
- DHT11湿度传感器
- OLED显示屏
- 蜂鸣器
- 按键
- LED指示灯

#### 四、实验步骤

1. **硬件连接**：
   - 将DS18B20温度传感器连接到开发板的指定引脚。
   - 根据DHT11湿度传感器的使用手册，将其接线与开发板连接。
   - 将OLED显示屏通过SPI接口与开发板相连。
   - 按照电路图连接蜂鸣器和LED。

2. **软件设计**：
   - 初始化系统时钟、GPIO口、ADC模块和中断。
   - 编写DS18B20和DHT11的数据采集函数，通过定时器中断定期读取传感器数据。
   - 实现时间和日期管理功能，包括闰年判断、月份天数计算和星期计算。
   - OLED显示屏的驱动程序编写，包括字符和字符串的显示、中文显示和滚动显示特效。
   - 实现闹钟功能，通过按键设置闹钟时间，并在到达设定时间时触发蜂鸣器和LED提示。
   - 编写按键扫描函数，检测用户的按键输入，并处理日期、时间、闹钟设置。

3. **调试与验证**：
   - 编写测试程序，检查温度和湿度传感器的读数是否正确显示在OLED屏上。
   - 调试时间、日期的显示与更新，确保系统能够正常滚动显示日期并正确切换月份和年分。
   - 通过按键设定闹钟，检查闹钟是否能够在设定时间响铃并亮起流水灯。

#### 五、实验结果

在实验过程中，成功实现了以下功能：

- 时间和日期能够准确显示在OLED屏幕上，且时间可以走动。
- 温度传感器DS18B20和湿度传感器DHT11能够准确采集环境数据并实时显示。
- 通过按键成功设置了闹钟，闹钟到达设定时间时，蜂鸣器发出警报声并亮起LED流水灯。
- OLED显示屏能够正确滚动显示日期信息，且通过附加功能可以通过按键修改时间和日期。

#### 六、实验总结

通过本次实验，熟悉了MSP430单片机的基本操作以及外设驱动编程，特别是对OLED显示屏、温度和湿度传感器的使用有了深入理解。同时，掌握了闹钟功能的实现原理，了解了如何通过按键进行时间和闹钟的设定与调整。整个项目增强了对单片机综合应用能力的认识，为日后进一步开发和优化嵌入式系统奠定了良好的基础。



#### code

https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2

【TB作品】MSP430F149单片机，数字时钟万年历程序，滚动显示特效

为什么要自己建站？在使用其他博客平台时，我感到受到了很多限制，尤其是在广告投放方面。所以我决定自己搭建一个博客网站，自由地管理内容和广告。如今开源社区资源丰富，自己搭建一个网站并不难，完全可以摆脱对其他平台的依赖。





## 准备工作

### 1. 选择服务器

首先，需要搞定一台 Linux 服务器。我选择了 RackNerd 的 VPS，主要是因为便宜。我买了一个2核心2G内存的套餐，一年大约150元。其实1核心1G的配置也足够使用，大家可以根据自己的需求选择。

如果你也想买服务器，可以参考这个[购买指南](https://p3terx.com/archives/cheap-vps-racknerd.html)。买服务器时，一定要测试一下国内网络是否可以直连服务器的 IP，不然使用起来会比较麻烦。

#### 为什么选择国外服务器？

我选择国外服务器是因为国内服务器需要进行公安备案，备案过程比较繁琐，而国外服务器则没有这个要求。

### 2. 购买域名

购买服务器后，接下来就是购买域名。我是在阿里云万网上买的域名。购买流程如下：

- 登录阿里云万网，网址：https://wanwang.aliyun.com/domain 。
- 搜索你想要的域名，确认可用后，添加到购物车。
- 按照提示完成支付并注册域名。建议一次买十年使用期，免得续费贵得要死。

域名DNS修改教程：https://help.aliyun.com/zh/dws/user-guide/change-dns-servers-for-a-domain-name

阿里云万网控制台：https://dc.console.aliyun.com/?spm=a2c4g.11186623.0.0.675b5c02MHI0oo


![image.png](/static/img/06d36b315d5ef3cc66a2fd7d1a9ac5f3.image.webp)


大家也看到了，我的域名是dong-blog.fun，fun结尾的是比较便宜的域名。阿里云万网控制台不好找啊，找半天都找不到域名列表，所以我贴这里。

### 3. 使用 Cloudflare 托管域名

为了更好地管理域名，我选择使用 Cloudflare 进行托管。Cloudflare 提供免费的 DNS 解析服务，相较于阿里云万网的收费服务，性价比更高。而且，阿里云万网的 DNS 解析对国外 IP 服务器的连接不一定稳定，因此使用 Cloudflare 是更好的选择。Cloudflare 中用户客户端到 Cloudflare 是自动可以https的，而 Cloudflare 到你自己的ip服务器，是可以用http的，当然，这些也是可以支持你去自定义的。

#### Cloudflare 托管教程

1. 在 Cloudflare 注册一个账户，并登录。不要开魔法去连接，他们官网是：https://www.cloudflare.com/
2. 添加你在阿里云万网购买的域名到 Cloudflare。
3. Cloudflare 会提供一组 DNS 服务器地址，将这些地址设置为你域名的 DNS 服务器（阿里云万网）。
4. 完成后，Cloudflare 会自动进行域名解析，你可以在 Cloudflare 控制面板查看解析状态。

## 搭建博客

### 1. 选择博客框架

现在有很多开源的博客框架可供选择。很多人使用 [Halo](https://github.com/halo-dev/halo)，但我觉得它的外观不太符合我的审美，所以选择了一个更年轻的项目——[VanBlog](https://github.com/Mereithhh/vanblog)。

#### Docker 部署 VanBlog

你可以参考 [VanBlog 官方文档](https://vanblog.mereith.com/guide/get-started.html#%E9%83%A8%E7%BD%B2%E6%96%B9%E5%BC%8F) 进行 Docker 部署，步骤清晰，适合新手操作。

### 2. 搜索引擎优化（SEO）

为了让我的博客在搜索引擎上有更好的表现，我在百度和谷歌都申请了站点 ID。具体操作如下：

#### 百度站点 ID 申请

1. 访问 [百度搜索资源平台](https://ziyuan.baidu.com/) 并注册账户。
2. 添加你的网站，并验证站点所有权。
3. 获取百度站点 ID，并将其添加到你的网站中。

#### 谷歌站点 ID 申请

1. 访问 [Google Search Console](https://search.google.com/search-console/about) 并使用 Google 帐户登录。
2. 添加你的网站，并验证站点所有权。
3. 获取谷歌站点 ID，并将其添加到你的网站中。

## 其他选择

我之前也使用过 WordPress，但发现它的许多功能都是收费的，且加载速度较慢，最终放弃了它。相比之下，VanBlog 更加轻量，部署简单，而且适合个性化定制。

## 如何用WordPress

docker compose 方法：



## 总结

通过这些步骤，你可以轻松搭建一个属于自己的博客网站。无论是服务器选择、域名购买、还是框架部署，每一步都有详细的教程可以参考。希望这篇教程对你有所帮助，愿你也能自由地在网络世界中畅游！

【建站教程】如何建设自己的博客网站？

# 效果





只能是共阳数码管：

![在这里插入图片描述](/static/img/images/00003.png)


# 模块

![在这里插入图片描述](/static/img/images/00004.png)


![在这里插入图片描述](/static/img/images/00005.png)


# 芯片介绍

![在这里插入图片描述](/static/img/images/00006.png)


TM1637芯片是一种常用于LED数码管显示控制的驱动芯片，下面是各引脚的详细说明：

1. **DIO (Data Input/Output)** - **管脚号: 17**

   - 功能: 串行数据输入/输出，DIO引脚在SCLK的低电平时接收数据，在SCLK的高电平时传输数据。每传输一个字节时，在第八个时钟的下降沿芯片内部将产生一个ACK信号。

2. **CLK (Clock Input)** - **管脚号: 18**

   - 功能: 时钟输入，数据在上升沿输入/输出。

3. **K1~K2 (Key Scan Data Input)** - **管脚号: 19-20**

   - 功能: 键扫数据输入，引脚的数据在显示周期结束后被锁存。

4. **SG1~SG8 (Segment Outputs)** - **管脚号: 2-9**

   - 功能: 段输出，用于控制数码管的段显示，也可用于键扫描。N管开漏输出。

5. **GRID6~GRID1 (Grid Outputs)** - **管脚号: 10-15**

   - 功能: 位输出，用于控制数码管的位显示。P管开漏输出。

6. **VDD (Logic Power Supply)** - **管脚号: 16**

   - 功能: 逻辑电源，提供5V±10%的电源电压。

7. **GND (Ground)** - **管脚号: 1**

   - 功能: 逻辑地，连接到系统地。

TM1637芯片通过上述引脚与外部电路进行连接，控制LED数码管的显示以及键盘扫描功能。


# code

```clike
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】TM1637芯片数码管，PIC16单片机驱动显示，Proteus仿真

![在这里插入图片描述](/static/img/images/00013.png)





# 功能

带闹钟和花样流水灯的LCD数显实时时钟设计（运用DS1302时钟模块，LCD显示，带万年历，时间到响音乐显示花样流水灯）

万年历显示

按键设置时间、闹钟

闹钟到了后音乐响、流水灯亮，维持10秒后自动关闭

# 硬件原理图

## LCD1602

![在这里插入图片描述](/static/img/images/00014.png)

## 独立按键

![在这里插入图片描述](/static/img/images/00015.png)

## LED灯

![在这里插入图片描述](/static/img/images/00016.png)

## ds1302

![在这里插入图片描述](/static/img/images/00017.png)

## 蜂鸣器

![在这里插入图片描述](/static/img/images/00018.png)

![在这里插入图片描述](/static/img/images/00019.png)


# 引脚汇总
```
### 1. LCD1602 显示屏连接
- RS (寄存器选择): P2 ^ 6
- RW (读写): P2 ^ 5
- EN (使能): P2 ^ 7
- 数据端口: P0 ^ 0 至 P0 ^ 7
### 2. 独立按键连接
- 按键1 (KEY_01): P3 ^ 0
- 按键2 (KEY_02): P3 ^ 1
- 按键3 (KEY_03): P3 ^ 2
- 按键4 (KEY_04): P3 ^ 3
### 3. LED 灯连接
- LED1: P2 ^ 0
- LED2: P2 ^ 1
- LED3: P2 ^ 2
- LED4: P2 ^ 3
- LED5: P2 ^ 4
- LED6: P2 ^ 5
### 4. DS1302 实时时钟模块连接
- RST (复位): P3 ^ 5
- SCLK (时钟): P3 ^ 6
- IO (数据输入/输出): P3 ^ 4
### 5. 蜂鸣器连接
- BEEP: P1 ^ 5
```

# 按键功能

这个单片机万年历程序的按键功能如下：

1. **按键 `key == 1`：**  

   - 主要用于切换设置项。  

   - 每按一次，`set` 值加 1（并在 0 到 9 之间循环），对应主页面和设置不同时间参数的界面。

   - `set = 0` 表示主页面，`set = 1 ~ 6` 分别对应秒、分、时、日、月、年的设置，`set = 7 ~ 9` 对应闹钟的秒、分、时设置。

2. **按键 `key == 2`：**  

   - 主要用于增加当前设置项的值。  

   - 根据 `set` 的值，增加相应的时间参数，比如 `set == 1` 时增加秒，`set == 2` 时增加分，依此类推。  

   - 对于日期和月份的设置，代码考虑了不同月份的天数及闰年规则。

3. **按键 `key == 3`：**  

   - 主要用于减少当前设置项的值。  

   - 同样根据 `set` 的值，减少相应的时间参数。  

   - 日期和月份的减少也考虑了月份天数和闰年的规则。

4. **按键 `key == 4`：**  

   - 退出设置模式，重置 `set` 为 0 并清除 LCD 显示，回到主界面。  

   - 最后调用 `set_time(&rtctime);` 函数应用设置后的时间，并刷新显示。

这个按键处理程序通过不同的按键实现了对时间和闹钟参数的设置和调整，且在日期设置中包含了对闰年的判断。通过 `set` 的值来区分不同的设置项目，并用 `key` 不同的值实现切换、增加、减少和确认操作。

# code

```clike
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】普中V2，数字时钟万年历显示，音乐闹钟，流水灯，Proteus仿真

通信聊天





任务要求：

用单片机实现与串口调试助手的通信，具体功能如下:

1、通过蓝牙模块（需要领取，如果使用笔记本电脑做该题，则只需要领取一个蓝牙模块，如果使用台式机则需要领取两个蓝牙模块外加一条USB转TTL线，尽量使用笔记本电脑，简化工作，学院的USB转TTL线并不多）实现与电脑串口调试助手的连接；（15分）

2、设定单片机的两种运行模式：接收消息/发送消息，同时按下按键A6和A7进行模式切换；（20分）

3、实现由电脑串口调试助手发送字母或数字给单片机，并由开发板OLED显示出来。(20分)

4、从PC端串口助手发送一个字符串到单片机，OLED显示屏显示该字符串，并通过按键上下左右选择其中任意一个字符，并将选中的字符发送回PC端。其中按键A4为上移方向、A5为下移方向、A6为左移方向、A7为右移方向。（25分）

5、单片机发送字符成功后流水灯亮起，接收到消息后蜂鸣器发出短暂声响。（20分）

# 实验报告

## 1. 实验背景

本实验旨在通过单片机实现与串口调试助手的通信，包含接收和发送消息、显示和选择字符串字符以及通过按键实现字符选择和发送的功能。硬件组件包括单片机、蓝牙模块、LCD1602显示屏、蜂鸣器、小灯流水灯和矩阵键盘。通过本实验，可以深入了解单片机串口通信及蓝牙模块的应用，并熟悉LCD显示及按键控制。

## 2. 硬件介绍与连接

### 2.1 硬件清单

- 单片机（如STC89C52）

- 蓝牙模块（如HC-05）

- LCD1602显示屏

- 蜂鸣器

- 小灯流水灯

- 矩阵键盘

- 其他必要的连接线和电阻

### 2.2 硬件连接

1. **蓝牙模块连接**

   - VCC -> 5V

   - GND -> GND

   - TXD -> RXD (单片机的串口接收引脚)

   - RXD -> TXD (单片机的串口发送引脚)

2. **LCD1602显示屏连接**

   - VCC -> 5V

   - GND -> GND

   - RS -> P2.6

   - RW -> P2.5

   - EN -> P2.7

   - 数据引脚 -> P0

3. **矩阵键盘连接**

   - 键盘引脚分别连接到单片机的P1口，如下：

     - key_10 -> P1.7

     - key_11 -> P1.6

     - key_12 -> P1.5

     - key_13 -> P1.4

     - key_14 -> P1.3

     - key_15 -> P1.2

     - key_16 -> P1.1

     - key_17 -> P1.0

4. **蜂鸣器连接**

   - BEEP -> 单片机P2.5引脚

5. **小灯流水灯连接**

   - 流水灯连接到单片机的P2.0到P2.3引脚

## 3. 设计原理

### 3.1 模式选择

- 单片机通过按键实现两种模式的切换：接收模式和发送模式。

- 按下按键时，模式在接收和发送之间切换，并在LCD显示屏上更新显示。

### 3.2 字符接收与显示

- 通过串口助手发送字符到单片机，单片机接收到字符后，存储到接收缓冲区，并在LCD1602显示屏上显示。

### 3.3 字符选择与发送

- 从PC端串口助手发送一个字符串到单片机，LCD显示屏显示该字符串。

- 用户通过按键选择字符串中的任意字符，并将选中的字符发送回PC端。

- 按键A4为上移，A5为下移，A6为左移，A7为右移。

### 3.4 发送与接收确认

- 单片机成功发送字符后，流水灯亮起。

- 接收到消息后，蜂鸣器发出短暂声响，提示用户。

## 4. 电路原理

### 4.1 串口通信原理

- 使用单片机的串口进行通信，配置波特率为9600bps。

- 通过蓝牙模块实现无线通信，单片机接收和发送数据。

### 4.2 LCD1602显示原理

- 使用并行通信控制LCD1602显示屏，显示接收到的字符串和光标位置。

- 根据接收的字符串长度进行显示更新和换行。

### 4.3 按键控制原理

- 检测按键的状态，根据按键输入控制光标的移动和模式的切换。

### 4.4 蜂鸣器与流水灯控制

- 使用单片机的I/O引脚控制蜂鸣器和流水灯，根据接收和发送的状态进行提示。

## 5. 程序设计原理

### 5.1 初始化

- 初始化串口、LCD1602显示屏、按键和中断。

- 设置定时器，用于定时检测按键状态和数据接收状态。

### 5.2 主程序

- 进入主循环，持续检测按键输入和串口接收状态。

- 根据模式进行数据接收和发送的处理。

### 5.3 串口中断服务程序

- 接收数据并存储到接收缓冲区。

- 根据接收完成标志进行蜂鸣器提示。

### 5.4 按键处理程序

- 根据按键输入控制光标的移动和模式的切换。

- 发送选中的字符到PC端，并更新发送成功标志。

### 5.5 显示刷新程序

- 根据接收的数据更新LCD显示屏的内容。

- 显示光标位置和当前选中的字符。

## 6. 代码实现分析

### 6.1 硬件定义

- 矩阵键盘的引脚定义：`P1.7` 到 `P1.0`

- LCD1602显示屏的引脚定义：`P2.6`、`P2.5`、`P2.7` 和 `P0` 口作为数据端口

- 蜂鸣器引脚定义：`P2.5`

- 小灯流水灯的引脚定义：`P2.0` 到 `P2.3`

### 6.2 按键扫描

通过扫描矩阵键盘的按键状态，确定按键值并进行去抖动处理，返回按键值。

```c
unsigned char read_key(void) {
    // 按键扫描逻辑
}
unsigned char getkey0(unsigned char mode) {
    // 去抖动处理和按键状态判断
}
```

### 6.3 LCD1602显示控制

通过LCD1602显示屏初始化、字符显示、字符串显示和光标位置设置等函数，实现显示屏的控制。

```c
void LCD_write_com(unsigned char com) {
    // 写命令到LCD
}
void LCD_write_data(unsigned char dataa) {
    // 写数据到LCD
}
void LCD_write_char(unsigned char x, unsigned char y, unsigned char dataa) {
    // 在指定位置写字符
}
void SetCurPosition(unsigned char x, unsigned char y) {
    // 设置光标位置
}
void LCD_init(void) {
    // 初始化LCD
}
```

### 6.4 串口通信

通过串口初始化、发送数据和接收数据中断处理，实现与PC端串口助手的通信。

```c
void send(unsigned char dat) {
    // 发送数据到串口
}
void SerInit(void) {
    // 初始化串口
}
void Uart_isr() interrupt 4 {
    // 串口中断服务程序
}
```

### 6.5 按键处理和显示更新

根据按键输入处理光标移动和模式切换，更新显示内容。

```c
void ProcessKeyInput(unsigned char keyinput) {
    // 按键处理逻辑
}
void OLED_DisplaysCertainLengthString(unsigned char *chr, unsigned char len) {
    // 显示一定长度的字符串
}
```

### 6.6 蜂鸣器和流水灯控制

通过蜂鸣器和流水灯的控制函数，提示发送和接收状态。

```c
void BeepAlarm(void) {
    // 控制蜂鸣器发声
}
void led_light(void) {
    // 控制流水灯亮起
}
```

## 7. 实验总结

通过本次实验，我们实现了单片机与串口调试助手的通信，掌握了蓝牙模块的应用，熟悉了LCD1602显示屏的控制方法。通过按键的交互操作，实现了字符的选择和发送，增强了对单片机控制的理解。同时，通过流水灯和蜂鸣器的提示，提升了用户体验。实验中我们遇到了一些问题，但通过调试和解决，使得系统能够稳定运行，达到了预期的效果。

![在这里插入图片描述](/static/img/images/00140.png)

作品：
```clike
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】51单片机，普中板子，通信聊天

# 功能





万年历

任务要求：

制作一个万年历，具有显示时间、日期、温度、湿度、闹钟功能。

1、OLED显示屏上显示日期和时钟（显示到秒，时间可走动）；（20分）

2、通过开发板上的温度传感器采集当前环境温度并显示在显示屏上；（20分）

3、通过湿度传感器采集当前环境湿度并显示在显示屏上；（20分）

4、通过独立按键设置闹钟，并在OLED上显示设置的闹钟时间，到达闹钟时间时蜂鸣器发出声响并持续一段时间，同时D1~D8以流水灯形式亮起；（20分）

5、日期为滚动特效；（20分）


注意：sbit DS18B20_PORT = P1 ^ 0;    //DS18B20数据口定义

sbit DHT11_DB = P1 ^ 1;

需要自行买ds18b20模块和dht11模块

![在这里插入图片描述](/static/img/images/00161.png)

![在这里插入图片描述](/static/img/images/00162.png)

演示视频：
```bash
链接：https://pan.baidu.com/s/1pKQ7XmnxbplJ_hJ1Z6XPRg?pwd=tpqv 
提取码：tpqv 
```


```bash
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```