在提升网站的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单片机，数字时钟万年历程序，滚动显示特效

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。