纯C实现的ymodem库，无额外依赖

news2024/11/28 22:34:36

本文目录

  • 1、引言
  • 2、理论
    • 2.1 YMODEM协议的主要特点
    • 2.2 YMODEM的工作原理
  • 3、代码
    • 3.1 main.cpp
    • 3.2 ymodem.c
    • 3.3 ymodem.h
  • 4、验证
    • 4.1 ymodem发送
    • 4.2 ymodem接收
  • 5、移植说明

文章对应视频教程：

暂无，可以关注我的B站账号等待更新。


点击图片或链接访问我的B站主页~~~

1、引言

在嵌入式开发和数据通信中，YMODEM协议因其可靠性和高效性而被广泛应用。作为一种文件传输协议，YMODEM在设备间的数据交换中发挥着重要作用。然而，市面上现有的YMODEM库大多采用C++或其他高级语言实现，这在某些资源受限的嵌入式环境中可能并不适用。为了解决这一问题，我们开发了一款完全用C语言编写的YMODEM库，旨在提供一个轻量、易用且高效的解决方案。本博客将详细介绍该库的设计原理、实现细节和使用方法，希望为广大嵌入式开发者提供有价值的参考。

2、理论

YMODEM是一个文件传输协议，它在XMODEM协议的基础上进行了扩展和改进。其主要特点和工作原理如下：

2.1 YMODEM协议的主要特点

数据包传输：

YMODEM使用数据包进行文件传输，每个数据包通常为1024字节（1KB），比XMODEM的128字节要大得多，从而提高了传输效率。

头文件传输：

YMODEM在传输文件数据之前，会先传输一个包含文件名、文件大小和修改时间等信息的头文件。这使得接收方能够提前知道文件的信息并进行相应处理。

错误检测和恢复：

采用CRC（循环冗余校验）进行数据包的错误检测，确保传输的可靠性。如果检测到错误，接收方可以请求重传。

2.2 YMODEM的工作原理

初始化传输：

发送方和接收方建立连接后，发送方首先发送一个包含文件信息的头文件数据包。
接收方接收到头文件后，进行校验并返回一个ACK（确认）信号。

数据包传输：

发送方开始按照顺序发送数据包，每个数据包包含数据内容和校验信息。
接收方接收到数据包后，进行校验。如果数据包无误，接收方返回ACK信号；如果有误，返回NAK（否认）信号，请求重传。

结束传输：

当所有数据包传输完毕后，发送方发送一个EOT（End of Transmission）信号，表示文件传输结束。
接收方接收到EOT信号后，返回一个ACK信号确认，并等待下一个文件的头文件数据包，或者断开连接。
在这里插入图片描述

通过这种方式，YMODEM协议实现了可靠且高效的文件传输，适用于需要稳定数据传输的嵌入式系统和其他应用场景。

3、代码

目前我的代码为了考虑可移植性，先在QT中完成的编写，但是适用与所有的嵌入式程序。

代码分三个部分：
main.c 完成ymodem需要的两个驱动函数，并进行注册和调用接收或发送；
ymodem.c 实现ymodem的接收和发送；
ymodem.h引出对应的函数接口。

开源地址

3.1 main.cpp

#include <QCoreApplication>
#include <QThread>
#include <QDebug>
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include "ymodem.h"


// 声明一个全局的 QSerialPort 对象
QSerialPort serial;

char ser_buff[1024*12] ;
long ser_len= 0;
int getData(char* data, unsigned int len, unsigned int mstime) {
    if (!serial.isOpen()) {
        qWarning() << "Serial port is not open.";
        return -1;
    }

    if(ser_len >= len )
    {
        memcpy(data, ser_buff, len);
        ser_len -= len;
        qWarning() << len;
        return len;
    }

    if (!serial.waitForReadyRead(mstime)) {
        qWarning() << "Read timeout.";
        return -1;
    }


    // QByteArray readData = serial.read(len);
    QByteArray readData = serial.readAll();
    int bytesRead = readData.size();

    memcpy(&ser_buff[ser_len],readData.data(),bytesRead);
    ser_len += bytesRead;

    if (ser_len >= len) {
        memcpy(data, readData.data(), len);
        ser_len -= len;
        memcpy(&ser_buff[0],&ser_buff[len],ser_len);
    }
    else
    {
        return -1;
    }

    qWarning() << len;

    return len;
}



int putData(char* data, unsigned int len, unsigned int mstime) {
    if (!serial.isOpen()) {
        qWarning() << "Serial port is not open.";
        return -1;
    }

    QByteArray writeData(data, len);
    qint64 bytesWritten = serial.write(writeData);

    if (bytesWritten == -1) {
        qWarning() << "Write failed.";
        return -1;
    }

    if (!serial.waitForBytesWritten(mstime)) {
        qWarning() << "Write timeout.";
        return -1;
    }
    qWarning() << writeData.data();
    return static_cast<int>(bytesWritten);
}

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    // 设置串口参数
    serial.setPortName("COM7");
    serial.setBaudRate(QSerialPort::Baud115200);
    serial.setDataBits(QSerialPort::Data8);
    serial.setParity(QSerialPort::NoParity);
    serial.setStopBits(QSerialPort::OneStop);
    serial.setFlowControl(QSerialPort::NoFlowControl);

    if (!serial.open(QIODevice::ReadWrite)) {
        qDebug() << "Failed to open port" << serial.portName();
        return -1;
    }else
    {
        qDebug() << "open port" << serial.portName();
    }

    // 示例使用
    // char sendData[] = "Hello, Serial Port!";
    // char receiveData[10];

    // int bytesSent = putData(sendData, strlen(sendData), 5000);
    // if (bytesSent > 0) {
    //     qDebug() << "Bytes sent:" << bytesSent;
    // } else {
    //     qWarning() << "Failed to send data.";
    // }

    // int bytesReceived = getData(receiveData, sizeof(receiveData), 5000);
    // if (bytesReceived > 0) {
    //     qDebug() << "Bytes received:" << bytesReceived;
    //     qDebug() << "Data received:" << QByteArray(receiveData, bytesReceived);
    // } else {
    //     qWarning() << "Failed to receive data.";
    // }

    ymodem_register(putData,getData);

    char buff[1024*502] =" {1,2,3}";
    // int ret = ymodem_send(buff,sizeof(buff), "2.txt");
    char name[128] = {};
    int ret = ymodem_recv(buff,sizeof(buff), name);

    qWarning() << "code is over."<<ret;
    // 程序退出前关闭串口
    serial.close();

    return 0;
    // int result = a.exec();

}

3.2 ymodem.c 

/**
 * @file ymodem.c
 * @author zhuxuanlin (you@domain.com)
 * @brief
 * @version 0.1
 * @date 2024-05-22
 *
 * @copyright Copyright (c) 2024
 *
 */

#include <stdio.h>
#include <string.h>
#include "ymodem.h"

#define SOH 0x01
#define STX 0x02
#define EOT 0x04
#define ACK 0x06
#define NAK 0x15
#define CAN 0x18
#define charC 0x43

#define PACKET_SIZE 128
#define PACKET_1K_SIZE 1024
#define PACKET_OVERHEAD 5
#define PACKET_TIMEOUT 2000
#define PACKET_TIMEOUT_TIMES 15

typedef enum{
    YM_FILEHEADER = 2,
    YM_DATA_TRANS,
    YM_DATA_OVER,
    YM_ABORT_TRANS
}ym_process;

static ymodem_st ym = {
    .get_data = 0,
    .put_data = 0
};
int ymodem_register(int (*put_data)(char* data,unsigned int len,unsigned int mstime),
                    int (*get_data)(char* data,unsigned int len,unsigned int mstime))
{
    ym.put_data = put_data;
    ym.get_data = get_data;
}

static const unsigned short crc_table[256] =
{
    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
    0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
    0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
    0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
    0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
    0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
    0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
    0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
    0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
    0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
    0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
    0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
    0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
    0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
    0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
    0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
    0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
    0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
    0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
    0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
    0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
    0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
    0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
    0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
    0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
    0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
    0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
    0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
    0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
    0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
    0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
    0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};

static unsigned short crc16(unsigned char *q, int len)
{
    unsigned short crc = 0;

    while (len-- > 0)
        crc = (crc << 8) ^ crc_table[((crc >> 8) ^ *q++) & 0xff];
    return crc;
}


static int __recv_packet(char* data,unsigned int* len, unsigned char packet_num,unsigned int mstime)
{
    if(len == NULL || data == NULL)
    {
        return -1;
    }

    char ym_packet[PACKET_1K_SIZE+PACKET_OVERHEAD];
    memset(ym_packet,0,sizeof(ym_packet));

    
    int ret = ym.get_data(ym_packet,1,PACKET_TIMEOUT);
    if(ret < 0 )
    {
        return -1;
    }
    if(ym_packet[0] != SOH &&  ym_packet[0] != STX)
    {
        if(ym_packet[0] == EOT)
        {
            return 0;
        }
        return -2;
    }
    long packet_len = (ym_packet[0] == SOH)?PACKET_SIZE:PACKET_1K_SIZE;

    ret = ym.get_data(&ym_packet[1],packet_len+4,PACKET_TIMEOUT);

    if(ret < 0 )
    {
        return -3;
    }
    if(!(ym_packet[1] ==  (char)packet_num && ym_packet[2] == (char)(~packet_num)))
    {
        char ack = NAK;
        ym.put_data(&ack,1,PACKET_TIMEOUT);
        return -4;
    }
    unsigned short crc = crc16(&ym_packet[3] , packet_len);

    if(ym_packet[packet_len + 3] == (char)((crc >> 8) & 0xFF) &&
        ym_packet[packet_len + 4] == (char)(crc & 0xFF))
    {
        memcpy(data,&ym_packet[3],packet_len);
        *len = packet_len;
    }
    else
    {
        return -6;
    }

    return packet_len;
}

static int __recv_filename(char* filename,unsigned long* filesize ,unsigned int mstime)
{
    char ym_packet[PACKET_1K_SIZE];
    memset(ym_packet,0,sizeof(ym_packet));
    unsigned long plen = 0;
    int ret = __recv_packet(ym_packet,&plen,0,mstime);
    if(ret < 0 || plen != PACKET_SIZE)
    {
        return -1;
    }

    if(filename == NULL || filesize == NULL)
    {
        for(int i = 0;i<PACKET_SIZE;i++)
        {
            if(ym_packet[i] != 0)
            {
                return -2;
            }
        }
        return 1;
    }
    int i = 0;

    while (ym_packet[i] != 0 && i < PACKET_SIZE) {
        filename[i] = ym_packet[i];
        i++;
    }

    i++;
    unsigned long fsize = 0;

    while (ym_packet[i] != 0 && i < PACKET_SIZE) {
        fsize = fsize * 10 + (ym_packet[i] - '0');
        i++;
    }

    *filesize = fsize;

    return 0;
}


int ymodem_recv(char *buff, long bufsize, char *filename)
{
    if (!ym.get_data || !ym.put_data) {
        return -1;  // 无效的功能指针
    }
    if(!buff || bufsize <= 0 || !filename )
    {
        return -1;
    }

    int rerty_times = PACKET_TIMEOUT_TIMES;
    int ret = -1;
    char ym_tbuf[2] = {0,0},ym_rchar = 0;
    long recv_bytes = 0 , single_packet_size = 0,file_size = 0;

    unsigned char __recv_flags = 0;

    ym_process process = YM_FILEHEADER;

    do{
        switch (process)
        {
        case YM_FILEHEADER:
            ym_tbuf[0] = charC;
            ym.put_data(&ym_tbuf[0],1,PACKET_TIMEOUT);
            ret = __recv_filename(filename,&file_size,PACKET_TIMEOUT);
            if(ret < 0)
            {
                rerty_times--;
            }
            else
            {
                if(file_size > bufsize)
                {
                    return -2;
                }
                ym_tbuf[0] = ACK;
                ym_tbuf[1] = charC;
                ym.put_data(ym_tbuf,2,PACKET_TIMEOUT);
                __recv_flags ++;
                process = YM_DATA_TRANS;
            }
            break;
        case YM_DATA_TRANS:
            ret = __recv_packet(&buff[recv_bytes],&single_packet_size,__recv_flags,PACKET_TIMEOUT);
            if(ret > 0)
            {
                recv_bytes += single_packet_size;
                __recv_flags++;
                ym_tbuf[0] = ACK;
                ym.put_data(ym_tbuf,1,PACKET_TIMEOUT);
                if(recv_bytes  > file_size + PACKET_1K_SIZE)
                {
                    int ack = CAN;
                    ym.put_data(&ack,1,PACKET_TIMEOUT);
                }
            }
            else if(ret == 0)
            {
                process = YM_DATA_OVER;
            }
            else
            {
                ym_tbuf[0] = NAK;
                ym.put_data(ym_tbuf,1,PACKET_TIMEOUT);  
            }

            break;
        case YM_DATA_OVER:
            ym_tbuf[0] = ACK;
            ym_tbuf[1] = charC;
            ym.put_data(ym_tbuf,2,PACKET_TIMEOUT);
            process = YM_ABORT_TRANS;
            break;
        case YM_ABORT_TRANS:
            ret = __recv_filename(NULL,NULL,PACKET_TIMEOUT);
            if(ret < 0)
            {
                rerty_times--;
            }
            else
            {
                ym_tbuf[0] = ACK;
                ym.put_data(ym_tbuf,1,PACKET_TIMEOUT);
                return recv_bytes;
            }
            break;
        default:
            break;
        }

    }while(rerty_times != 0);
    return -1;
}

static int __send_packet(char* data,unsigned int len, unsigned char packet_num,unsigned int mstime)
{

    if(len>PACKET_1K_SIZE || data == NULL)
    {
        return -1;
    }

    char ym_packet[PACKET_1K_SIZE+PACKET_OVERHEAD];
    memset(ym_packet,0,sizeof(ym_packet));
    
    int packet_len = (len<=PACKET_SIZE)?PACKET_SIZE:PACKET_1K_SIZE;

    ym_packet[0] = (packet_len == PACKET_SIZE)?SOH:STX;
    ym_packet[1] = packet_num;
    ym_packet[2] = ~packet_num;


    memcpy(&ym_packet[3],data,len);

    unsigned short crc = crc16(&ym_packet[3] , packet_len);
    ym_packet[packet_len +3] = (crc >> 8) & 0xFF; // Append the higher byte of the CRC.
    ym_packet[packet_len +4] = crc & 0xFF; // Append the lower byte of the CRC.

    int ret = ym.put_data(ym_packet,packet_len+PACKET_OVERHEAD,mstime);

    return (ret > 5)?ret -5:ret;
}

static int __send_filename(char* filename,unsigned long filesize ,unsigned int mstime)
{
    char ym_packet[PACKET_SIZE];
    memset(ym_packet,0,sizeof(ym_packet));
    unsigned char plen = 0;

    if(filename != NULL || filesize != 0)
    {
        plen = sprintf(ym_packet,"%s", filename); // 文件名
        plen++;
        plen += sprintf(&ym_packet[plen], "%d", filesize);
        return __send_packet(ym_packet,plen,0,mstime);
    }
    return __send_packet(ym_packet,PACKET_SIZE,0,mstime);
}


int ymodem_send(char *buff,long bufsize, const char *filename)
{
    if (!ym.get_data || !ym.put_data) {
        return -1;  // 无效的功能指针
    }

    if(!buff || bufsize == 0 || !filename)
    {
        return -1;
    }

    int rerty_times = PACKET_TIMEOUT_TIMES;
    int ret = -1;
    char ym_rbuf[2] = {0,0},ym_tchar = 0;
    long sent_bytes = 0 , single_packet_size = 0;
    unsigned char __send_flags = 0;

    ym_process process = YM_FILEHEADER;

    do{
        switch (process)
        {
        case YM_FILEHEADER:
            ret = ym.get_data(ym_rbuf,1,PACKET_TIMEOUT);
            if(ret == 1 && ym_rbuf[0] == charC)
            {
                ret = __send_filename(filename,bufsize,PACKET_TIMEOUT);
                ret = ym.get_data(ym_rbuf,2,PACKET_TIMEOUT);
                if(ret == 2 && ym_rbuf[0] == ACK && ym_rbuf[1] == charC)
                {
                    __send_flags++;
                    process = YM_DATA_TRANS; 
                }
                else if(ret < 0)
                {
                    rerty_times--;
                }
            }
            else
            {   
                rerty_times--;
            }
            break;
        case YM_DATA_TRANS:
            // 单次发送数据量
            single_packet_size = (bufsize - sent_bytes > PACKET_1K_SIZE) ? PACKET_1K_SIZE : bufsize - sent_bytes;
            ret = __send_packet(&buff[sent_bytes], single_packet_size,__send_flags,PACKET_TIMEOUT); // 发送数据包
            ret = ym.get_data(ym_rbuf,1,PACKET_TIMEOUT);
            if(ret == 1 && ym_rbuf[0] == ACK)
            {
                __send_flags++;
                sent_bytes += single_packet_size;
                if(sent_bytes >= bufsize || sent_bytes < 0)
                {
                    process = YM_DATA_OVER; 
                }
            }
            else if(ret == 1 && ym_rbuf[0] == NAK)
            {
                rerty_times--;
                // 重发
            }
            else if(ret == 1 && ym_rbuf[0] == CAN)
            {
                break;
            }
            else if(ret < 0)
            {
                rerty_times--;
            }
            break;
        case YM_DATA_OVER:
            ym_tchar = EOT;
            ret = ym.put_data(&ym_tchar,1,PACKET_TIMEOUT);
            ret = ym.get_data(ym_rbuf,1,PACKET_TIMEOUT);
            if(ret == 1 && ym_rbuf[0] == ACK) 
            {
                ret = ym.get_data(ym_rbuf,1,PACKET_TIMEOUT);
                if(ret == 1 && ym_rbuf[0] == charC)
                {
                    process = YM_ABORT_TRANS; 
                }

            } 
            else if(ret == 1 && ym_rbuf[0] == NAK)  
            {
                // 重发
            }
            else if(ret < 0)
            {
                rerty_times--;
            }      


            break;
        case YM_ABORT_TRANS:
            ret = __send_filename(NULL,0,PACKET_TIMEOUT);
            ret = ym.get_data(ym_rbuf,1,PACKET_TIMEOUT);
            if(ret == 1 && ym_rbuf[0] == ACK )
            {
                // 正常退出
                return sent_bytes;
            }
            else if(ret < 0)
            {
                // 部分异常退出
                return 1;
            }
            break;
        default:
            break;
        }

    }while(rerty_times != 0);
    return -1;
}

3.3 ymodem.h

#ifndef __YMODEM_H__
#define __YMODEM_H__

#ifdef __cplusplus
extern "C" {
#endif

typedef struct 
{
    /* int -1发送失败，>0 接收字节数，data 数据buff , len 接收数据长度 , 超时时间 ms */
    int (*get_data)(char* data,unsigned int len,unsigned int mstime);
    /* int -1发送失败，>0 发送字节数，data 数据buff , len 发送数据长度 , 超时时间 ms */
    int (*put_data)(char* data,unsigned int len,unsigned int mstime);
}ymodem_st;

extern int ymodem_register(int (*put_data)(char* data,unsigned int len,unsigned int mstime),
                            int (*get_data)(char* data,unsigned int len,unsigned int mstime));
extern int ymodem_recv(char *buff, long bufsize, char *filename);
extern int ymodem_send(char *buff, long bufsize, const char *filename);

#ifdef __cplusplus
}
#endif
#endif  /* __YMODEM_PORT_H__ */

4、验证

使用QT和超级终端进行验证。
在电脑中开启虚拟串口，
一端连接QT打开的串口，
一端连接超级终端的串口。
通过虚拟串口模拟两个串口设备的ymodem通信过程。

4.1 ymodem发送

在这里插入图片描述

4.2 ymodem接收

在这里插入图片描述

经过验证以上代码的ymodem接收和发送都没有问题。

5、移植说明

首先实现这两个驱动函数。

/* int -1发送失败，>0 接收字节数，data 数据buff , len 接收数据长度 , 超时时间 ms */
int (*get_data)(char* data,unsigned int len,unsigned int mstime);
/* int -1发送失败，>0 发送字节数，data 数据buff , len 发送数据长度 , 超时时间 ms */
int (*put_data)(char* data,unsigned int len,unsigned int mstime);

在函数中使用这个函数注册驱动函数给ymodem协议库

    ymodem_register(put_data,get_data);

最后，调用这个两个函数来进行接收或者发送：

    int ret = ymodem_send(buff,sizeof(buff), "2.txt");
    int ret = ymodem_recv(buff,sizeof(buff), name);

时间流逝、年龄增长，是自己的磨炼、对知识技术的应用，还有那不变的一颗对嵌入式热爱的心！

到这里就结束了！希望大家给我的文章和B站视频
点赞o(￣▽￣)ｄ、关注(o)/~、评论(▽)！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1848131.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

纳米硅（SiNP）可用于制造锂离子电池 纳米硅粉为其代表产品

纳米硅（SiNP）可用于制造锂离子电池 纳米硅粉为其代表产品

纳米硅&#xff08;SiNP&#xff09;可用于制造锂离子电池 纳米硅粉为其代表产品 纳米硅&#xff08;SiNP&#xff09;指尺寸在纳米尺度范围内的硅颗粒。纳米硅具有光吸收谱宽、表面活性高、比表面积大、机械强度高、电学性能好等优势&#xff0c;在石油化工、建筑工程、电子电…
阅读更多...
Docker 搭建 MinIO 对象存储

Docker 搭建 MinIO 对象存储

Docker 搭建 MinIO 对象存储 一、MinIO MinIO 是一个高性能的对象存储服务器&#xff0c;用于构建云存储解决方案。MinIO 允许你存储非结构化数据&#xff08;如图片、视频、日志文件等&#xff09;以对象的形式。MinIO 提供简单的部署选项和易于使用的界面&#xff0c;允许你…
阅读更多...
宠物健康顾问系统的设

宠物健康顾问系统的设

计 管理员账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0c;顾问管理&#xff0c;用户管理&#xff0c;健康知识管理&#xff0c;管理员管理&#xff0c;论坛管理&#xff0c;公告管理 顾问账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0…
阅读更多...
数学-奇异值

数学-奇异值

有点名词党 奇异值的计算通常涉及矩阵的奇异值分解Singular Value Decomposition, SVD。奇异值分解是将一个矩形矩阵 ( A ) 分解为三个矩阵的乘积&#xff1a; [ A U ΣVT] 其中&#xff1a; - ( U ) 是一个 ( m m ) 的正交矩阵&#xff0c;它的列向量是 ( A AT) 的特征向…
阅读更多...
【windows|009】计算机网络基础知识

【windows|009】计算机网络基础知识

&#x1f341;博主简介&#xff1a; &#x1f3c5;云计算领域优质创作者 &#x1f3c5;2022年CSDN新星计划python赛道第一名 &#x1f3c5;2022年CSDN原力计划优质作者 ​ &#x1f3c5;阿里云ACE认证高级工程师 ​ &#x1f3c5;阿里云开发者社区专家博主 &#x1f48a;交流社…
阅读更多...
开放式耳机有什么好处？推荐几款开放式蓝牙耳机

开放式耳机有什么好处？推荐几款开放式蓝牙耳机

现在开放式蓝牙耳机面市,迅速占领了市场一席之地后。各大品牌商纷纷参与研制,开放蓝牙耳机与的竞争日趋激烈。这种开放式耳机崛起的速度,连我作为一个数码博主都得感叹一句绝了&#xff0c;所以我花了大几千块&#xff0c;又买了现在很热门的五款开放式耳机&#xff0c;这篇收集…
阅读更多...
【SkiaSharp绘图08】SKPaint方法：自动换行、是否乱码、字符偏移、边界、截距、文本轮廓、测量文本

【SkiaSharp绘图08】SKPaint方法：自动换行、是否乱码、字符偏移、边界、截距、文本轮廓、测量文本

文章目录 SKPaint方法BreakText 计算指定宽度内可绘制的字符个数ContainsGlyphs字体是否包含文本字符(是否会乱码)GetGlyphOffsets 字符偏移量GetGlyphPositions 偏移坐标GetGlyphWidths 每个字符的宽度与边界GetHorizontalTextIntercepts 轮廓截距GetPositionedTextIntercepts…
阅读更多...
Python100题（含答案）

Python100题（含答案）

温馨提示&#xff1a;篇幅有限&#xff0c;已打包文件夹&#xff0c;获取方式在&#xff1a;文末 温馨提示&#xff1a;篇幅有限&#xff0c;已打包文件夹&#xff0c;获取方式在&#xff1a;文末 篇幅有限&#xff0c;这份完整版的Python100题已经上传&#xff0c;朋友们如果…
阅读更多...
Python xlwt库：写excel表格

Python xlwt库：写excel表格

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
Linux开发讲课8--- linux的5种IO模型

Linux开发讲课8--- linux的5种IO模型

一、这里IO是什么 操作系统为了保护自己&#xff0c;设计了用户态、内核态两个状态。应用程序一般工作在用户态&#xff0c;当调用一些底层操作的时候&#xff08;比如 IO 操作&#xff09;&#xff0c;就需要切换到内核态才可以进行 服务器从网络接收的大致流程如下&#xff1…
阅读更多...
Excel条件格式的经典用法

Excel条件格式的经典用法

目录&#xff1a; 一、自动设置填充颜色 二、设置Excel到期自动销毁 三、隔行自动标记 四、美化表格 五、快速突出显示重复值 六、标记空单元格 七、突出显示前N名单元格数值 八、表格添加新内容自动加边框 一、自动设置填充颜色 1、选择内容 首先我们选中表格的数据…
阅读更多...
SEGGER Embedded Studio IDE移植embOS

SEGGER Embedded Studio IDE移植embOS

SEGGER Embedded Studio IDE移植embOS 一、背景介绍二、任务目标三、技术实现3.1 获得embOS3.2 创建SES工程3.2.1 创建初始Solution和Project3.2.2 制作项目文件结构3.2.3 移植embOS库和有关头文件3.2.3.1 头文件3.2.3.2 库文件3.2.3.3 创建RTOSInit.c源文件3.2.3.4 OS_Error.c…
阅读更多...
第1章 MySQL数据库概述

第1章 MySQL数据库概述

1.1 基本概念 数据库是什么&#xff1f; 存储数据的地方 DB&#xff1a;数据库&#xff08;Database&#xff09; 为什么要用数据库&#xff1f; 因为应用程序产生的数据是在内存中的&#xff0c;如果程序退出或者是断电了&#xff0c;则数据就会消失。使用数据库是为了…
阅读更多...
【中学教资科目二】02中学课程

【中学教资科目二】02中学课程

02中学课程 第一节 课程概述1.1 课程的分类 第二节 课程组织2.1 课程内容的文本表现形式2.2 课程评价 第三节 基础教育课程改革3.1 基础教育改革的目标3.2 新课改的课程结构 第一节 课程概述 1.1 课程的分类 学校课程有多种类型&#xff0c;其中最利于学生系统掌握人类所取得的…
阅读更多...
收费4980的AI批量混剪，素材技术方法工具配套，详细拆解！

收费4980的AI批量混剪，素材技术方法工具配套，详细拆解！

前几天有朋友跟我讲&#xff0c;他说有做旅游卡的&#xff0c;他们收费4980元&#xff0c;给500张卡&#xff0c;送AI批量混剪技术&#xff0c;问我们有没有&#xff1f; 批量混剪技术&#xff0c;这个其他早在2022年的时候我们就已经使用了。有开通抖音企业号的朋友都知道&am…
阅读更多...
HarmonyOS角落里的知识—Stage模型应用程序

HarmonyOS角落里的知识—Stage模型应用程序

开发态包结构 在DevEco Studio上创建一个项目工程&#xff0c;并尝试创建多个不同类型的Module。根据实际工程中的目录对照本章节进行学习&#xff0c;可以有助于理解开发态的应用程序结构。 图1 项目工程结构示意图&#xff08;以实际为准&#xff09; 工程结构主要包含的文…
阅读更多...
舒适佩戴，享受沉浸式音乐体验，西圣AVA2耳机体验

舒适佩戴，享受沉浸式音乐体验，西圣AVA2耳机体验

平时不管是听音乐&#xff0c;还是打电话&#xff0c;戴上一副耳机都可以让我们获得更好的隐私性&#xff0c;并且在公共场所&#xff0c;比如办公室、车厢里&#xff0c;也可以获得属于自己的空间。现在市面上耳机的选择非常多&#xff0c;音质、续航和佩戴的舒适度是我们选择…
阅读更多...
2004年-2022年 全国31省市场分割指数数据

2004年-2022年 全国31省市场分割指数数据

市场分割指数在经济学领域是一个关键的概念&#xff0c;特别是在评估不同区域市场一体化水平时。陆铭等学者深入研究了市场分割问题&#xff0c;并对市场分割指数给出了定义&#xff1a;它是一个衡量在相同时间点不同区域或同一区域在不同时间点的某类商品相对价格差异的指标。…
阅读更多...
homework 2024.06.17 math, UI

homework 2024.06.17 math, UI

A的宽度225 B的宽度150 这样画出来就比较标准&#xff0c; 225 * 2 150 * 3 2A 3B
阅读更多...
技术驱动会展：展位导航系统的架构与实现

技术驱动会展：展位导航系统的架构与实现

随着会展行业的快速发展&#xff0c;大型会展中心面临着如何提升参展者体验、提高招商效率的挑战。针对客户反馈的展馆面积大、展位查找困难等问题&#xff0c;维小帮提出一套智慧会展导航解决方案&#xff0c;旨在通过先进的室内导航技术提升会展中心的运营效率和参展者的满意…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023