0

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

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

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

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

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

4

1 回答 1

0

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

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

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

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

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

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

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

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

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

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

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

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

lion@palmbeach.freeserve.co.uk

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

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

/* 32 位以 2 为底的二进制数 + 100 位以 1 为底的二进制数组成数字*/

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

/* 字节 1 - */

/* 字节 2 - */

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

/* 字节 4 - 32 位数字的 8 位 CRC 后缀，稍后完成 */

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

/* 字节 6 - 二进制基数为 1 的计数 9 到 16*/

/* 字节 7 - 计数 17 到 24 ... */

/* 字节 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++;
}
于 2015-05-17T12:30:14.150 回答