有没有其他存储二进制数的方法答案

【问题标题】：are there any other methods of storing binary numbers有没有其他存储二进制数的方法
【发布时间】：2015-07-28 11:34:49
【问题描述】：

二进制数通常以固定位置的 MSB 和 LSB 存储；从 LSB 到 MSB，每个位的权重加倍。还有其他存储二进制数的方法吗？

传统方式可能是最有效的方式，当需要最少数量的逻辑电子比特来表示一个数字时，这种方式也有一些缺点。一个缺点是，当顺序计数时，LSB 的切换非常高，因为它会在每次递增计数时切换状态。我试图打乱每个位的权重，以便在顺序计数时，表示二进制数的每个位都具有相同的切换量。实现这种方法有很多优点，尽管数字需要更多的位。

一个优点是可以延长 EEPROM 的寿命，因为在代表存储数字的所有物理单元中都会发生等量的切换。超频 CPU、纠错等的另一个优势。

如果示波器探头检查传统地址总线，则 LSB 有很多 HARD 工作，而 MSB 非常空闲。

传统方法：（数字） 0000 0001 0010 0011 0100 新提出的方法： (加扰编码器)(数字)

【问题讨论】：

这对于堆栈溢出来说太宽泛了。在这里你应该问有直接答案的问题（你的问题的直接答案是：“是的，当然有。你可以随心所欲地存储它们”，这不是很有用！）。为了解决您对平衡每个位的权重的担忧，您可以走极端并使用 base-1 类型编码（“计数 1”），但它会很慢并且您无法计数非常高.
加扰编码器编号前缀，是内存单元内每个位位置权重的查找表，这样在对所有内存单元进行顺序计数时具有相同数量的逻辑状态切换。跨度>
我认为您要么是在误解的情况下进行操作，要么是想改写您的问题。通常，EEPROM 中的值不会不断变化。您设置它们并保留它们，通常作为固件或其他 ROM。虽然它们可以更改，但 EEPROM 通常具有您可以预期对其进行闪存的总周期数，但这不受单个位周期的控制。
谢谢，我在想 EEPROM 被用来存储计数，例如车门打开的次数，它会在大约 100,000 次计数时开始失败。正在使用 EEPROM，因为它是非易失性的。
使用我提出的系统，您可以获得数量级更多的计数，因为 LSB 存储单元没有死亡。但是你确实需要更多的位

标签： binary numbers memory-address base eeprom

【解决方案1】：

这样的二进制数字系统怎么样？当以非常高的总线速度计数时，晶体管不会过热，因此会限制时钟速度。

该解决方案使用 base-2 和 base-1 二进制来生成数字。

((base-2 二进制数)*size_of_in_bits(base-1 二进制数)) + base-1 二进制数

所以对于 16 位总线，高字节二进制基数为 2，低字节二进制基数为 1，最大计数为 ((2^8)-1)*8)+8) = 2048

EEPROM寿命问题的解决方案可能是：

使用在写入新数据时仅更改所需单元的 EEPROM，以最大限度地延长使用寿命。

4 个字节（32 位）用于数字的 base-2 部分，13 个字节（100 位）用于数字的 base-1 部分。

((32 位 base-2 二进制数) x 100) + (100 位二进制 base-1 计数计数器)

最大计数为 (((2^32)-1) *100)+100) = 429,496,729,700

此方法应从 EEPROM 或 FLASH 存储器中获得最大寿命，对于 FLASH 存储器，基数为 1 的数字应反转存储，因为擦除状态为逻辑 1。

EEPROM 可以读取、递增、写入，数量要大 2 个数量级，达到 100 万而不是 10000 万。

给我发一封电子邮件，我可以给你程序，它在 MVS 2013 控制台中运行。

lion@palmbeach.freeserve.co.uk

/* www.goatelectronics.com 解决方案 */

/*这个程序是用来测试eeprom寿命的，写入同一个页面和单元格*/

/* 32 位 base-2 二进制数 + 100 bit base-1 二进制数组成数字*/

/* byte 0 - 最高有效字节，二进制 base-2 数字 */

/* 字节 1 - */

/* 字节 2 - */

/* byte 3 - 最低有效字节，二进制 base-2 数字 */

/* byte 4 - 32bit 数字的 8 位 CRC 后缀，稍后做 */

/* 字节 5 - 二进制基数为 1 的计数 0 到 8 */

/* 字节 6 - 二进制 base-1 数的第 9 到 16 个计数*/

/* byte 7 - count 17 to 24 of ... */

/* 字节 8 - 计数 25 到 32 */

/* 字节 9 - 计数 33 到 40 */

/* 字节 10 - 计数 41 到 48 */

/* 字节 11 - 计数 49 到 56 */

/* 字节 12 - 计数 57 到 64 */

/* 字节 13 - 计数 65 到 72 */

/* 字节 14 - 计数 73 到 80 */

/* 字节 15 - 计数 81 到 88 */

/* 字节 16 - 计数 89 到 96 */

/* 字节 17 - 计数 97 到 100 */

#include "stdafx.h"
#include <iostream>
#include <conio.h>
using namespace std;

/* emulate the eeprom *here* , byte read and write */
unsigned char eeprom[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
                       0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 

unsigned int EEPROM_read (void)
{
unsigned char i_u8;
unsigned int value_u32, value_A_u32, value_B_u32, value_C_u32,      value_D_u32 = 0;
unsigned int base_1_u32 = 0;
value_A_u32 = eeprom[0];
value_A_u32 = value_A_u32 << 24;
value_B_u32 = eeprom[1];
value_B_u32 = value_B_u32 << 16;
value_C_u32 = eeprom[2];
value_C_u32 = value_C_u32 << 8;
value_D_u32 = eeprom[3];
value_u32 = value_A_u32 | value_B_u32 | value_C_u32 | value_D_u32;
/* eeprom[4]  reserved location for CRC checksum! */

value_u32 = value_u32 * 100;

for (i_u8 = 5; eeprom[i_u8] == 0xFF; i_u8++)
{
    base_1_u32 = base_1_u32 + 8;
}

switch (eeprom[i_u8])
{
case 0x80: base_1_u32 = base_1_u32 + 1;
    break;
case 0xC0: base_1_u32 = base_1_u32 + 2;
    break;
case 0xE0: base_1_u32 = base_1_u32 + 3;
    break;
case 0xF0: base_1_u32 = base_1_u32 + 4;
    break;
case 0xF8: base_1_u32 = base_1_u32 + 5;
    break;
case 0xFC: base_1_u32 = base_1_u32 + 6;
    break;
case 0xFE: base_1_u32 = base_1_u32 + 7;
    break;
default:; /*if here, faulty EEPROM with base-1 number*/
}

value_u32 = value_u32 + base_1_u32;

return (value_u32);

}

void EEPROM_write(unsigned int number_u32)
{
unsigned char i_u8, remainder_u8;
unsigned int value_u32;

value_u32 = number_u32;

value_u32 = value_u32 / 100;

eeprom[0] = (unsigned char)((value_u32 & 0xFF000000) >> 24);
eeprom[1] = (unsigned char)((value_u32 & 0x00FF0000) >> 16);
eeprom[2] = (unsigned char)((value_u32 & 0x0000FF00) >> 8);
eeprom[3] = (unsigned char)((value_u32 & 0x000000FF));

remainder_u8 = (unsigned char)(number_u32 % 100);
if (!remainder_u8)
{
    for (i_u8 = 5; i_u8 < 18; i_u8++)
    {
        eeprom[i_u8] = 0x00;
    }
}

for (i_u8 = 5; remainder_u8 >=8; i_u8++)
{
    eeprom[i_u8] = 0xFF;
    remainder_u8 = remainder_u8 - 8;
}

switch (remainder_u8)
{
case 1: eeprom[i_u8] = 0x80;
    break;
case 2: eeprom[i_u8] = 0xC0;
    break;
case 3: eeprom[i_u8] = 0xE0;
    break;
case 4: eeprom[i_u8] = 0xF0;
    break;
case 5: eeprom[i_u8] = 0xF8;
    break;
case 6: eeprom[i_u8] = 0xFC;
    break;
case 7: eeprom[i_u8] = 0xFE;
    break;
default:; /**/
}
}


int _tmain(int argc, _TCHAR* argv[])
{
unsigned char i_u8;
unsigned int test_number_u32;
unsigned int loop_u32 = 0;

while (loop_u32 <0xFFFFFFFF)
{
    test_number_u32 = EEPROM_read();
    test_number_u32++;
    EEPROM_write(test_number_u32);

    for (i_u8 = 0; i_u8 < 18; i_u8++)
    {
        printf(" %x", eeprom[i_u8]);
    }
    printf(" \n");
    loop_u32++;
}

【讨论】：