我正在尝试缩短微控制器的CPU ID（STM32F1）。
cpu id由3个字（3 x 4字节）组成。这是从3个单词构建的id字符串：980416578761680031125348904
我发现了一个非常有用的库。
库是Hashids，并且有一个C代码。
我尝试使用“Code Blocks IDE”在PC上构建测试代码，代码可以运行。
但是当我将代码移动到嵌入式端（Keil v5 IDE）时，我在strdup（）函数上出现错误：“strdup隐式声明函数”。
问题与strdup函数有关，不是标准的库函数，也没有包含在string.h中。
我将避免使用自定义函数（模仿strdup的行为）替换strdup函数以避免内存泄漏，因为strdup使用malloc复制字符串。
是否有不同的方法来压缩长数？
感谢您的帮助！
＆LT; --- ---附录＆GT;
这是使用strdup的函数。
/* common init */
struct hashids_t *
hashids_init3(const char *salt, size_t min_hash_length, const char *alphabet)
{
struct hashids_t *result;
unsigned int i, j;
size_t len;
char ch, *p;
hashids_errno = HASHIDS_ERROR_OK;
/* allocate the structure */
result = _hashids_alloc(sizeof(struct hashids_t));
if (HASHIDS_UNLIKELY(!result)) {
hashids_errno = HASHIDS_ERROR_ALLOC;
return NULL;
}
/* allocate enough space for the alphabet and its copies */
len = strlen(alphabet) + 1;
result->alphabet = _hashids_alloc(len);
result->alphabet_copy_1 = _hashids_alloc(len);
result->alphabet_copy_2 = _hashids_alloc(len);
if (HASHIDS_UNLIKELY(!result->alphabet || !result->alphabet_copy_1
|| !result->alphabet_copy_2)) {
hashids_free(result);
hashids_errno = HASHIDS_ERROR_ALLOC;
return NULL;
}
/* extract only the unique characters */
result->alphabet[0] = '\0';
for (i = 0, j = 0; i < len; ++i) {
ch = alphabet[i];
if (!strchr(result->alphabet, ch)) {
result->alphabet[j++] = ch;
}
}
result->alphabet[j] = '\0';
/* store alphabet length */
result->alphabet_length = j;
/* check length and whitespace */
if (result->alphabet_length < HASHIDS_MIN_ALPHABET_LENGTH) {
hashids_free(result);
hashids_errno = HASHIDS_ERROR_ALPHABET_LENGTH;
return NULL;
}
if (strchr(result->alphabet, ' ')) {
hashids_free(result);
hashids_errno = HASHIDS_ERROR_ALPHABET_SPACE;
return NULL;
}
/* copy salt */
result->salt = strdup(salt ? salt : HASHIDS_DEFAULT_SALT);
result->salt_length = (unsigned int) strlen(result->salt);
/* allocate enough space for separators */
result->separators = _hashids_alloc((size_t)
(ceil((float)result->alphabet_length / HASHIDS_SEPARATOR_DIVISOR) + 1));
if (HASHIDS_UNLIKELY(!result->separators)) {
hashids_free(result);
hashids_errno = HASHIDS_ERROR_ALLOC;
return NULL;
}
/* non-alphabet characters cannot be separators */
for (i = 0, j = 0; i < strlen(HASHIDS_DEFAULT_SEPARATORS); ++i) {
ch = HASHIDS_DEFAULT_SEPARATORS[i];
if ((p = strchr(result->alphabet, ch))) {
result->separators[j++] = ch;
/* also remove separators from alphabet */
memmove(p, p + 1,
strlen(result->alphabet) - (p - result->alphabet));
}
}
/* store separators length */
result->separators_count = j;
/* subtract separators count from alphabet length */
result->alphabet_length -= result->separators_count;
/* shuffle the separators */
hashids_shuffle(result->separators, result->separators_count,
result->salt, result->salt_length);
/* check if we have any/enough separators */
if (!result->separators_count
|| (((float)result->alphabet_length / (float)result->separators_count)
> HASHIDS_SEPARATOR_DIVISOR)) {
unsigned int separators_count = (unsigned int)ceil(
(float)result->alphabet_length / HASHIDS_SEPARATOR_DIVISOR);
if (separators_count == 1) {
separators_count = 2;
}
if (separators_count > result->separators_count) {
/* we need more separators - get some from alphabet */
int diff = separators_count - result->separators_count;
strncat(result->separators, result->alphabet, diff);
memmove(result->alphabet, result->alphabet + diff,
result->alphabet_length - diff + 1);
result->separators_count += diff;
result->alphabet_length -= diff;
} else {
/* we have more than enough - truncate */
result->separators[separators_count] = '\0';
result->separators_count = separators_count;
}
}
/* shuffle alphabet */
hashids_shuffle(result->alphabet, result->alphabet_length,
result->salt, result->salt_length);
/* allocate guards */
result->guards_count = (unsigned int) ceil((float)result->alphabet_length
/ HASHIDS_GUARD_DIVISOR);
result->guards = _hashids_alloc(result->guards_count + 1);
if (HASHIDS_UNLIKELY(!result->guards)) {
hashids_free(result);
hashids_errno = HASHIDS_ERROR_ALLOC;
return NULL;
}
if (HASHIDS_UNLIKELY(result->alphabet_length < 3)) {
/* take some from separators */
strncpy(result->guards, result->separators, result->guards_count);
memmove(result->separators, result->separators + result->guards_count,
result->separators_count - result->guards_count + 1);
result->separators_count -= result->guards_count;
} else {
/* take them from alphabet */
strncpy(result->guards, result->alphabet, result->guards_count);
memmove(result->alphabet, result->alphabet + result->guards_count,
result->alphabet_length - result->guards_count + 1);
result->alphabet_length -= result->guards_count;
}
/* set min hash length */
result->min_hash_length = min_hash_length;
/* return result happily */
return result;
}
答案 0 :(得分：2)
真正的问题似乎是
是否有不同的方法来压缩长数？
有很多。它们在几个方面有所不同，包括输入的哪些位有助于输出，有多少输入映射到同一输出，以及输入的哪种变换方式使输出保持不变。
作为一个简单的例子，您可以通过以下任何方法将输入压缩为单个位：
或者，您可以使用输入中的1位数作为输出压缩为7位。
当然，这些特定选项都不是您感兴趣的。
也许你会更感兴趣为96位输入产生32位输出。 请注意，在这种情况下，平均会有至少2个 64 可能的输入映射到每个可能的输出。 这仅取决于输入和输出的大小，而不是转换的任何细节。
例如，假设你有
uint32_t *cpuid = ...;
指向硬件CPU ID。您可以从中生成一个32位值，该值取决于输入的所有位，只需执行以下操作：
uint32_t cpuid32 = cpuid[0] ^ cpuid[1] ^ cpuid[2];
这是否适合您的目的取决于您打算如何使用它。
答案 1 :(得分：1)
您可以像这样轻松实现strdup：
char* strdup (const char* str)
{
size_t size = strlen(str);
char* result = malloc(size);
if(result != NULL)
{
memcpy(result, str, size+1);
}
return result;
}
话虽这么说，在嵌入式系统上使用malloc或strdup很可能只是无意义的做法，see this。你也不会使用浮点数。总的来说，这个图书馆似乎是由一个有桌面头脑的人写的。
如果要在嵌入式系统上实现类似链式哈希表的内容，则应使用静态分配的内存池而不是malloc。因为这个原因，我可能会使用非链式的（在重复时，在缓冲区中选择下一个空闲点）。
答案 2 :(得分：0)
唯一的器件ID寄存器（96位）位于地址0x1FFFF7E8下。它是工厂编程的并且是只读的。您可以直接读取它而无需使用任何其他外部库。例如：
unsigned int b = *(0x1FFFF7E8);
应该为您提供唯一设备ID的前32位（31：0）。如果要检索字符串，就像提到的库一样，以下内容应该有效：
sprintf(id, "%08X%08X%08X", *(0x1FFFF7E8), *(0x1FFFF7E8 + 4), *(0x1FFFF7E8 + 8);
可能需要一些额外的铸造，但通常这就是图书馆所做的。有关详细信息，请参阅STM32F1xx参考手册（RM0008）的第30.2节。对于Cortex-M4系列MCU，要读取的确切内存位置是不同的。