827 lines
21 KiB
C
827 lines
21 KiB
C
/*
|
||
* @Author:
|
||
* @day: 2023-04-11 08:21:19
|
||
* @LastEditors: xxx
|
||
* @LastEditTime: 2023-08-15 10:14:58
|
||
* @Description:
|
||
* email:
|
||
* Copyright (c) 2023 by xxx, All Rights Reserved.
|
||
*/
|
||
|
||
#include "../inc/lib.h"
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include "cmac.h"
|
||
const uint8_t _days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
||
const uint16_t _month_days[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
|
||
static uint32_t crc32_table[256]; // CRC32表
|
||
|
||
// ASSIC码数组转字符串
|
||
void assic_to_str(uint8_t *assic, uint8_t len, uint8_t *str)
|
||
{
|
||
for (uint8_t i = 0; i < len; i++)
|
||
{
|
||
if (assic[i] == 0)
|
||
{
|
||
str[i] = 48;
|
||
}
|
||
else
|
||
{
|
||
str[i] = (char)assic[i];
|
||
}
|
||
}
|
||
}
|
||
|
||
// 每隔三位数加逗号，将数字转为每隔3位整数由逗号“,”分隔的字符串
|
||
void add_commas(uint32_t num, char *result)
|
||
{
|
||
char temp[64];
|
||
sprintf(temp, "%d", num);
|
||
|
||
int32_t len = strlen(temp);
|
||
int32_t commas = (len - 1) / 3;
|
||
|
||
int32_t index = 0;
|
||
int32_t resultIndex = 0;
|
||
for (int32_t i = len - 1; i >= 0; i--)
|
||
{
|
||
result[resultIndex++] = temp[i];
|
||
index++;
|
||
if (index % 3 == 0 && commas > 0)
|
||
{
|
||
result[resultIndex++] = ',';
|
||
commas--;
|
||
}
|
||
}
|
||
result[resultIndex] = '\0';
|
||
|
||
// Reverse the result string
|
||
int32_t start = 0;
|
||
int32_t end = resultIndex - 1;
|
||
while (start < end)
|
||
{
|
||
char temp = result[start];
|
||
result[start] = result[end];
|
||
result[end] = temp;
|
||
start++;
|
||
end--;
|
||
}
|
||
}
|
||
|
||
void get_cpu_id(uint32_t *id)
|
||
{
|
||
#ifdef STM32
|
||
// 获取CPU唯一的ID
|
||
id[0] = *(uint32_t *)(UID_BASE);
|
||
id[1] = *(uint32_t *)(UID_BASE + 4);
|
||
id[2] = *(uint32_t *)(UID_BASE + 8);
|
||
#endif
|
||
}
|
||
|
||
uint32_t cpu_encrypt(void)
|
||
{
|
||
uint32_t cpuid[3];
|
||
#ifdef STM32
|
||
// 获取CPU唯一的ID
|
||
cpuid[0] = *(uint32_t *)(UID_BASE);
|
||
cpuid[1] = *(uint32_t *)(UID_BASE + 4);
|
||
cpuid[2] = *(uint32_t *)(UID_BASE + 8);
|
||
#endif
|
||
// 加密算法,很简单的加密算法
|
||
uint32_t encrypt_code = (cpuid[0] >> 3) + (cpuid[1] >> 1) + (cpuid[2] >> 2);
|
||
return encrypt_code;
|
||
}
|
||
|
||
// 判断加密
|
||
BOOL cpu_judge_encrypt(uint32_t cupid_encrypt)
|
||
{
|
||
uint32_t cpuid[4];
|
||
#ifdef STM32
|
||
// 获取CPU唯一的ID
|
||
cpuid[0] = *(uint32_t *)(UID_BASE);
|
||
cpuid[1] = *(uint32_t *)(UID_BASE + 4);
|
||
cpuid[2] = *(uint32_t *)(UID_BASE + 8);
|
||
#endif
|
||
// 加密算法,很简单的加密算法
|
||
cpuid[3] = (cpuid[0] >> 3) + (cpuid[1] >> 1) + (cpuid[2] >> 2);
|
||
// 检查Flash中的UID是否合法
|
||
return (cupid_encrypt == cpuid[3]);
|
||
}
|
||
|
||
void convert_seconds(uint32_t total_seconds, char *date)
|
||
{
|
||
uint32_t days = total_seconds / 86400;
|
||
uint32_t hours = (total_seconds % 86400) / 3600;
|
||
uint32_t minutes = (total_seconds % 3600) / 60;
|
||
uint32_t seconds = total_seconds % 60;
|
||
if (days > 0)
|
||
{
|
||
if (days > 1000)
|
||
{
|
||
sprintf(date, "%02d d %02d h", days, hours);
|
||
}
|
||
else
|
||
{
|
||
sprintf(date, "%02d d %02d h %02d m", days, hours, minutes);
|
||
}
|
||
}
|
||
else if (hours > 0)
|
||
{
|
||
sprintf(date, "%02d h %02d m %02d s", hours, minutes, seconds);
|
||
}
|
||
else if (minutes > 0)
|
||
{
|
||
sprintf(date, "%02d m %02d s", minutes, seconds);
|
||
}
|
||
else
|
||
{
|
||
sprintf(date, "%02d s", seconds);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Generate the CRC32 lookup table.
|
||
*
|
||
* This function generates the CRC32 lookup table used for fast computation of the
|
||
* CRC32 checksum. The table is generated using the polynomial 0xEDB88320, which is a
|
||
* common polynomial used in CRC32 calculations.
|
||
*/
|
||
static void generate_crc32_table()
|
||
{
|
||
static BOOL is_init = FALSE;
|
||
if (is_init)
|
||
{
|
||
return;
|
||
}
|
||
uint32_t polynomial = 0xEDB88320;
|
||
for (uint32_t i = 0; i < 256; i++)
|
||
{
|
||
uint32_t crc = i;
|
||
for (uint32_t j = 0; j < 8; j++)
|
||
{
|
||
crc = (crc & 1) ? (crc >> 1) ^ polynomial : crc >> 1;
|
||
}
|
||
crc32_table[i] = crc;
|
||
}
|
||
is_init = TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 版本号1.0拆解成1和0
|
||
* @param {uint8_t} *version_str
|
||
* @param {uint8_t} *hi
|
||
* @param {uint8_t} *lo
|
||
* @return {*}
|
||
*/
|
||
void version_split(uint8_t *version_str, uint8_t *hi, uint8_t *lo)
|
||
{
|
||
uint8_t flag = 1;
|
||
|
||
for (uint8_t i = 0; version_str[i] != '\0'; i++)
|
||
{
|
||
if (version_str[i] == '.')
|
||
{
|
||
flag = 0;
|
||
continue;
|
||
}
|
||
|
||
if (flag)
|
||
{
|
||
*hi = *hi * 10 + (version_str[i] - '0');
|
||
}
|
||
else
|
||
{
|
||
*lo = *lo * 10 + (version_str[i] - '0');
|
||
}
|
||
}
|
||
}
|
||
|
||
// 反序数组
|
||
void reverse(uint8_t *buf, uint16_t len)
|
||
{
|
||
uint8_t tmp;
|
||
uint16_t i;
|
||
for (i = 0; i < len / 2; i++)
|
||
{
|
||
tmp = buf[i];
|
||
buf[i] = buf[len - i - 1];
|
||
buf[len - i - 1] = tmp;
|
||
}
|
||
}
|
||
|
||
/***
|
||
* @brief 判断是否在数组中
|
||
* @param {uint8_t} *arr 数组
|
||
* @param {uint8_t} len 数组长度
|
||
* @param {uint8_t} val 要判断的值
|
||
* @return {*} TRUE: 在数组中
|
||
*/
|
||
BOOL is_in_array(uint16_t *arr, uint16_t len, uint16_t val)
|
||
{
|
||
uint16_t i;
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
if (arr[i] == val)
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
/**
|
||
* 计算并返回指定数据区域crc的值
|
||
*
|
||
* @param data: 待计算的数据区首地址
|
||
* @param length: 待计算的数据区长度
|
||
*
|
||
* @return crc计算的结果
|
||
*/
|
||
uint16_t crc16_compute(const uint8_t *const data, uint16_t length)
|
||
{
|
||
uint16_t crcVal = 0xffff;
|
||
const uint8_t *ptr = data;
|
||
|
||
for (uint16_t i = 0; i < length; i++)
|
||
{
|
||
crcVal ^= (uint16_t)*ptr++;
|
||
|
||
for (uint8_t j = 0; j < 8; j++)
|
||
{
|
||
if (crcVal & 0x0001)
|
||
{
|
||
crcVal = (crcVal >> 1) ^ 0x8401;
|
||
}
|
||
else
|
||
{
|
||
crcVal >>= 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
return crcVal;
|
||
}
|
||
|
||
/**
|
||
* @brief Calculate the CRC32 value of a data buffer.
|
||
*
|
||
* This function calculates the CRC32 value of a data buffer using the lookup table method.
|
||
* The lookup table is generated using the polynomial 0xEDB88320, which is a common polynomial used in CRC32 calculations.
|
||
*
|
||
* @param data The data buffer to calculate the CRC32 value of.
|
||
* @param length The length of the data buffer in bytes.
|
||
* @return The CRC32 value of the data buffer.
|
||
*/
|
||
uint32_t crc32_compute(const uint8_t *const data, uint16_t length)
|
||
{
|
||
generate_crc32_table();
|
||
uint32_t crc = 0xFFFFFFFF;
|
||
for (size_t i = 0; i < length; i++)
|
||
{
|
||
crc = (crc >> 8) ^ crc32_table[(crc ^ data[i]) & 0xFF];
|
||
}
|
||
return crc ^ 0xFFFFFFFF;
|
||
}
|
||
|
||
/**
|
||
* @brief 计算 64 位 CRC 值
|
||
*
|
||
* 根据给定的数据块和长度，使用 AES-CMAC 算法和 CRC32 算法计算 64 位 CRC 值。
|
||
* 使用这个函数heap设置0x800
|
||
*
|
||
* @param data 数据块指针
|
||
* @param length 数据块长度
|
||
*
|
||
* @return 返回计算得到的 64 位 CRC 值
|
||
*/
|
||
uint64_t crc64_compute(const uint8_t *const data, const uint16_t length)
|
||
{
|
||
uint8_t cmac_key[] = {
|
||
0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
|
||
0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C}; // 密钥
|
||
uint8_t dst[4];
|
||
uint8_t mic[16];
|
||
uint8_t *p;
|
||
uint32_t lo = 0, hi = 0;
|
||
AES_CMAC_CTX AesCmacCtx[1]; // 密钥扩展表
|
||
AES_CMAC_Init(AesCmacCtx); // 完成密钥扩展表的初始化
|
||
AES_CMAC_SetKey(AesCmacCtx, cmac_key); // 完成密钥扩展表数据 // 存放生成校验数据的数组
|
||
AES_CMAC_Update(AesCmacCtx, data, length & 0xFF); // 完成数据的奇偶校验
|
||
AES_CMAC_Final(mic, AesCmacCtx); // 生成16个字节的校验表
|
||
uint32_t xor_vol = (uint32_t)((uint32_t)mic[3] << 24 | (uint32_t)mic[2] << 16 | (uint32_t)mic[1] << 8 | (uint32_t)mic[0]); // 取表4个字节作为校验码
|
||
p = (uint8_t *)&xor_vol;
|
||
osel_memcpy(dst, p, 4);
|
||
lo = (uint32_t)dst[0] << 24 | (uint32_t)dst[1] << 16 | (uint32_t)dst[2] << 8 | (uint32_t)dst[3];
|
||
hi = crc32_compute(data, length);
|
||
return ((uint64_t)hi << 32) | lo;
|
||
}
|
||
|
||
/**
|
||
* 计算并返回指定数据区域异或的值
|
||
*
|
||
* @param data: 待计算的数据区首地址
|
||
* @param length: 待计算的数据区长度
|
||
*
|
||
* @return 异或计算的结果
|
||
*/
|
||
uint8_t xor_compute(const uint8_t *const data, uint16_t length)
|
||
{
|
||
uint16_t i;
|
||
const uint8_t *ptr = data;
|
||
uint8_t xor = 0;
|
||
for (i = 0; i < length; i++)
|
||
{
|
||
xor ^= *ptr;
|
||
ptr++;
|
||
}
|
||
return xor;
|
||
}
|
||
|
||
// 通过bit位获取置1个数量
|
||
uint8_t get_bit_num(uint8_t bit)
|
||
{
|
||
uint8_t num = 0;
|
||
while (bit)
|
||
{
|
||
if (bit & 0x01)
|
||
{
|
||
num++;
|
||
}
|
||
bit >>= 1;
|
||
}
|
||
return num;
|
||
}
|
||
|
||
// 通过bit位获取置1的位置
|
||
BOOL is_bit_set(int32_t x, int32_t k)
|
||
{
|
||
int32_t mask = 1 << k;
|
||
return (x & mask) != 0;
|
||
}
|
||
|
||
// 判断数组是否全是同一个值
|
||
BOOL is_same_value(uint8_t *buf, uint16_t len, uint8_t value)
|
||
{
|
||
uint16_t i;
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
if (buf[i] != value)
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// 检查是否是闰年
|
||
uint8_t is_leap_year(uint16_t year)
|
||
{
|
||
return (year % 400 == 0) || (year % 100 != 0 && year % 4 == 0);
|
||
}
|
||
|
||
// 检查日期是否合法
|
||
BOOL is_valid_date(uint8_t year, uint8_t month, uint8_t day)
|
||
{
|
||
if (year < 1 || month < 1 || month > 12 || day < 1)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
uint8_t days_in_month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
||
|
||
// 如果是闰年，2月有29天
|
||
if (is_leap_year(year))
|
||
{
|
||
days_in_month[1] = 29;
|
||
}
|
||
|
||
return day <= days_in_month[month - 1];
|
||
}
|
||
|
||
// 检查时间是否合法
|
||
BOOL is_valid_time(uint8_t hour, uint8_t minute, uint8_t second)
|
||
{
|
||
return (hour < 24) &&
|
||
(minute < 60) &&
|
||
(second < 60);
|
||
}
|
||
|
||
// 检查日期和时间是否合法
|
||
BOOL is_valid_datetime(uint8_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second)
|
||
{
|
||
return is_valid_date(year, month, day) && is_valid_time(hour, minute, second);
|
||
}
|
||
|
||
// 计算从1970年1月1日到给定年月日的天数
|
||
uint32_t days_since_1970(uint16_t year, uint8_t month, uint8_t day)
|
||
{
|
||
static const uint8_t month_days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
||
uint32_t days = 0;
|
||
uint16_t y = 1970;
|
||
|
||
// 计算整年过去的天数
|
||
while (y < year)
|
||
{
|
||
days += is_leap_year(y) ? 366 : 365;
|
||
y++;
|
||
}
|
||
|
||
// 计算当前年份中过去的天数
|
||
for (int32_t m = 0; m < month - 1; m++)
|
||
{
|
||
days += month_days[m];
|
||
if (m == 1 && is_leap_year(year))
|
||
{ // 如果是2月且是闰年，多加一天
|
||
days++;
|
||
}
|
||
}
|
||
|
||
// 加上当前月的天数
|
||
days += day - 1; // 因为day是从1开始的，而我们需要的是从0开始的偏移量
|
||
|
||
return days;
|
||
}
|
||
|
||
// 将日期转换为秒数
|
||
uint32_t date_to_seconds(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second)
|
||
{
|
||
uint32_t secs = 0;
|
||
uint32_t days = days_since_1970(year, month, day);
|
||
secs = days * 24 * 60 * 60; // 一天有24小时，每小时有60分钟，每分钟有60秒
|
||
secs += hour * 60 * 60 + minute * 60 + second;
|
||
return secs;
|
||
}
|
||
|
||
// 函数用于将秒数转换为日期和时间,年份4位
|
||
void seconds_to_date(uint32_t total_seconds, rtc_date_t *date, rtc_time_t *time)
|
||
{
|
||
uint16_t year = 1970; // Unix时间戳的起始年份
|
||
uint8_t month = 1;
|
||
uint8_t day = 1;
|
||
uint32_t seconds = total_seconds;
|
||
uint8_t hours, minutes, secs;
|
||
|
||
// 正确处理小时、分钟和秒
|
||
hours = (seconds / 3600) % 24;
|
||
minutes = (seconds / 60) % 60;
|
||
secs = seconds % 60;
|
||
|
||
// 计算日期
|
||
uint32_t days = total_seconds / (24 * 3600);
|
||
seconds = total_seconds % (24 * 3600); // 更新seconds为剩余秒数
|
||
|
||
for (; days > 0; days--)
|
||
{
|
||
// 当前月份的天数
|
||
uint8_t days_in_month = 31;
|
||
if (month == 2)
|
||
{
|
||
days_in_month = is_leap_year(year) ? 29 : 28;
|
||
}
|
||
else if (month == 4 || month == 6 || month == 9 || month == 11)
|
||
{
|
||
days_in_month = 30;
|
||
}
|
||
|
||
if (++day > days_in_month)
|
||
{
|
||
day = 1;
|
||
if (++month > 12)
|
||
{
|
||
month = 1;
|
||
year++;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 将结果存储到结构体中
|
||
date->year = year;
|
||
date->month = month;
|
||
date->day = day;
|
||
time->hour = hours;
|
||
time->minute = minutes;
|
||
time->second = secs;
|
||
}
|
||
|
||
// 计算一年中的第几天
|
||
uint16_t dayOfyear(uint16_t year, uint8_t month, uint8_t day)
|
||
{
|
||
uint8_t month_days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
||
uint16_t total;
|
||
total = day;
|
||
if (month > 2 && is_leap_year(year))
|
||
total += 1;
|
||
for (uint8_t i = 0; i < month - 1; i++)
|
||
{
|
||
total += month_days[i];
|
||
}
|
||
return total;
|
||
}
|
||
|
||
// 计算一年中的第几周
|
||
uint16_t weekOfyear(uint16_t year, uint8_t month, uint8_t day)
|
||
{
|
||
uint16_t day_of_year = dayOfyear(year, month, day);
|
||
return (day_of_year - 1) / 7 + 1;
|
||
}
|
||
|
||
// 获取今天星期几
|
||
uint8_t get_weekday(uint16_t year, uint8_t month, uint8_t day)
|
||
{
|
||
uint8_t w = 0;
|
||
if (month == 1 || month == 2)
|
||
{
|
||
month += 12;
|
||
year--;
|
||
}
|
||
w = (day + 2 * month + 3 * (month + 1) / 5 + year + year / 4 - year / 100 + year / 400) % 7;
|
||
return w + 1;
|
||
}
|
||
|
||
// 传入十六进制0x23 返回十进制23
|
||
uint8_t hex_format_dec(uint8_t hex)
|
||
{
|
||
char buf[4];
|
||
osel_memset((uint8_t *)buf, 0, 4);
|
||
sprintf(buf, "%x", hex);
|
||
int32_t dec = 0;
|
||
int32_t weight = 1;
|
||
int32_t len = strlen(buf);
|
||
for (int32_t i = len - 1; i >= 0; i--)
|
||
{
|
||
if (buf[i] >= '0' && buf[i] <= '9')
|
||
{
|
||
dec += (buf[i] - '0') * weight;
|
||
}
|
||
else if (buf[i] >= 'A' && buf[i] <= 'F')
|
||
{
|
||
dec += (buf[i] - 'A' + 10) * weight;
|
||
}
|
||
else if (buf[i] >= 'a' && buf[i] <= 'f')
|
||
{
|
||
dec += (buf[i] - 'a' + 10) * weight;
|
||
}
|
||
weight *= 10;
|
||
}
|
||
return dec;
|
||
}
|
||
|
||
// 传入十进制23 返回十六进制0x23
|
||
uint8_t dec_format_hex(uint8_t dec)
|
||
{
|
||
char buf[4];
|
||
osel_memset((uint8_t *)buf, 0, 4);
|
||
sprintf(buf, "%d", dec);
|
||
uint8_t hex = 0;
|
||
uint8_t len = strlen(buf);
|
||
for (uint8_t i = 0; i < len; i++)
|
||
{
|
||
char c = buf[i];
|
||
if (c >= '0' && c <= '9')
|
||
{
|
||
hex = hex * 16 + (c - '0');
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
return hex;
|
||
}
|
||
|
||
/**
|
||
* @brief 日期时间转时间戳
|
||
* @param {rtc_date_t} date
|
||
* @param {rtc_time_t} time
|
||
* @return {*}
|
||
* @note 年份是从2000年开始的
|
||
*/
|
||
uint32_t time2stamp(const rtc_date_t *const date, const rtc_time_t *const time)
|
||
{
|
||
uint32_t result;
|
||
uint16_t year = date->year + 2000;
|
||
// (time->hour - 0) * 3600 中的0改成8是北京时间的时区
|
||
result = (year - 1970) * 365 * 24 * 3600 + (_month_days[date->month - 1] + date->day - 1) * 24 * 3600 + (time->hour - 0) * 3600 + time->minute * 60 + time->second;
|
||
result += (date->month > 2 && (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0)) * 24 * 3600; // 闰月
|
||
year -= 1969;
|
||
result += (year / 4 - year / 100 + year / 400) * 24 * 3600; // 闰年
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief 时间戳转日期时间
|
||
* @param {uint32_t} stamp
|
||
* @param {rtc_date_t} *date
|
||
* @param {rtc_time_t} *time
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
void stamp2time(uint32_t stamp, rtc_date_t *date, rtc_time_t *time)
|
||
{
|
||
uint32_t days;
|
||
uint16_t leap_num;
|
||
|
||
time->second = stamp % 60;
|
||
stamp /= 60; // 获取分
|
||
time->minute = stamp % 60;
|
||
// stamp += 8 * 60; // 不需要加8小时
|
||
stamp /= 60; // 获取小时
|
||
time->hour = stamp % 24;
|
||
days = stamp / 24;
|
||
leap_num = (days + 365) / 1461;
|
||
if (((days + 366) % 1461) == 0)
|
||
{
|
||
date->year = (days / 366) + 1970 - 2000;
|
||
date->month = 12;
|
||
date->day = 31;
|
||
}
|
||
else
|
||
{
|
||
days -= leap_num;
|
||
date->year = (days / 365) + 1970 - 2000;
|
||
days %= 365;
|
||
days += 1;
|
||
if (((date->year % 4) == 0) && (days == 60))
|
||
{
|
||
date->month = 2;
|
||
date->day = 29;
|
||
}
|
||
else
|
||
{
|
||
if (((date->year % 4) == 0) && (days > 60))
|
||
--days;
|
||
for (date->month = 0; _days[date->month] < days; date->month++)
|
||
{
|
||
days -= _days[date->month];
|
||
}
|
||
++date->month;
|
||
date->day = days;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**************************排序**************************/
|
||
static void swap(uint16_t *a, uint16_t *b)
|
||
{
|
||
uint16_t t = *a;
|
||
*a = *b;
|
||
*b = t;
|
||
}
|
||
|
||
static int32_t partition(uint16_t arr[], int32_t low, int32_t high)
|
||
{
|
||
uint16_t pivot = arr[high];
|
||
int32_t i = (low - 1);
|
||
for (int32_t j = low; j <= high - 1; j++)
|
||
{
|
||
if (arr[j] < pivot)
|
||
{
|
||
i++;
|
||
swap(&arr[i], &arr[j]);
|
||
}
|
||
}
|
||
swap(&arr[i + 1], &arr[high]);
|
||
return (i + 1);
|
||
}
|
||
|
||
// 快速排序
|
||
void quicksort(uint16_t arr[], int32_t low, int32_t high)
|
||
{
|
||
if (low < high)
|
||
{
|
||
int32_t pi = partition(arr, low, high);
|
||
quicksort(arr, low, pi - 1);
|
||
quicksort(arr, pi + 1, high);
|
||
}
|
||
}
|
||
|
||
// 插入排序 数据集小的时候效率高
|
||
void insertion_sort(uint16_t arr[], uint16_t n)
|
||
{
|
||
uint16_t i, j;
|
||
uint16_t key;
|
||
for (i = 1; i < n; i++)
|
||
{
|
||
key = arr[i];
|
||
j = i;
|
||
|
||
// 将大于key的元素向后移动一个位置
|
||
while (j > 0 && arr[j - 1] > key)
|
||
{
|
||
arr[j] = arr[j - 1];
|
||
j = j - 1;
|
||
}
|
||
arr[j] = key;
|
||
}
|
||
}
|
||
|
||
/**************************线性拟合**************************/
|
||
/**
|
||
* @brief 计算平均值
|
||
*
|
||
* 根据给定的点集和指示标志，计算 X 或 Y 坐标的平均值。
|
||
*
|
||
* @param points 点集指针
|
||
* @param count 点集数量
|
||
* @param isX 是否计算 X 坐标的平均值，为 1 则计算 X 坐标的平均值，为 0 则计算 Y 坐标的平均值
|
||
*
|
||
* @return 返回计算得到的平均值
|
||
*/
|
||
static float32 average(const point_t *points, int32_t count, int32_t isX)
|
||
{
|
||
float32 sum = 0.0f;
|
||
for (int32_t i = 0; i < count; ++i)
|
||
{
|
||
sum += isX ? points[i].x : points[i].y;
|
||
}
|
||
return sum / count;
|
||
}
|
||
|
||
/**
|
||
* @brief 计算线性回归函数值
|
||
*
|
||
* 根据给定的 x 值和线性函数参数，计算并返回线性回归函数的值。 y = a * x + b
|
||
*
|
||
* @param x 输入的 x 值
|
||
* @param param 线性函数参数结构体，包含斜率 a 和截距 b
|
||
*
|
||
* @return 线性回归函数的值
|
||
*/
|
||
static float32 calculate_linear_regression_func(float32 x, linear_func_param_t param)
|
||
{
|
||
return param.a * x + param.b;
|
||
}
|
||
|
||
/**
|
||
* @brief 计算线性回归参数
|
||
*
|
||
* 根据给定的数据点集合，计算线性回归的参数。
|
||
*
|
||
* @param points 数据点集合指针
|
||
* @param count 数据点数量
|
||
*
|
||
* @return 线性回归参数结构体
|
||
*
|
||
* @note 如果数据点数量少于2，则会输出错误日志并断言失败
|
||
*/
|
||
linear_func_param_t calculate_linear_regression(const point_t *points, int32_t count)
|
||
{
|
||
if (count < 2)
|
||
{
|
||
LOG_PRINT("参数points至少需要两组数据\n");
|
||
DBG_ASSERT(FALSE __DBG_LINE);
|
||
}
|
||
|
||
float32 xAverage = average(points, count, 1);
|
||
float32 yAverage = average(points, count, 0);
|
||
float32 sumXY = 0.0, sumXX = 0.0;
|
||
|
||
for (int32_t i = 0; i < count; ++i)
|
||
{
|
||
float32 dX = points[i].x - xAverage;
|
||
float32 dY = points[i].y - yAverage;
|
||
sumXY += dX * dY;
|
||
sumXX += dX * dX;
|
||
}
|
||
|
||
linear_func_param_t result;
|
||
result.a = sumXY / sumXX;
|
||
result.b = yAverage - result.a * xAverage;
|
||
return result;
|
||
}
|
||
|
||
// 求线性度 公式 dYmax / Y * 100%
|
||
float32 get_linearity_value(const point_t *points, int32_t count, linear_func_param_t param)
|
||
{
|
||
float32 dYMax = 0.0f;
|
||
for (int32_t i = 0; i < count; ++i)
|
||
{
|
||
float32 y = calculate_linear_regression_func(points[i].x, param);
|
||
float32 dY = ABS(y - points[i].y);
|
||
if (dY > dYMax)
|
||
dYMax = dY;
|
||
}
|
||
|
||
float32 yFirst = calculate_linear_regression_func(points[0].x, param);
|
||
float32 yLast = calculate_linear_regression_func(points[count - 1].x, param);
|
||
return dYMax / ABS(yLast - yFirst) * 100;
|
||
}
|
||
|
||
/**
|
||
// 示例使用
|
||
int main()
|
||
{
|
||
point_t points[] = {{1, 2}, {2, 3}, {3, 4}}; // 示例点数组
|
||
int count = sizeof(points) / sizeof(points[0]);
|
||
linear_func_param_t param = calculate_linear_regression(points, count);
|
||
printf("Linear Regression: y = %f * x + %f\n", param.a, param.b);
|
||
|
||
double linearity = get_linearity_value(points, count, param);
|
||
printf("Linearity Value: %f%%\n", linearity);
|
||
|
||
return 0;
|
||
}
|
||
*/
|
||
|
||
/**************************线性拟合**************************/
|