Question

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

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

一个优点是EEPROM的寿命将延长，因为在表示存储的数字的所有物理单元中发生等量的切换。超频cpu，纠错等等的另一个好处。

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

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

Answer 1

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

该解决方案使用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位二进制base-1计数器）

最大数量为（（（2 ^ 32）-1）* 100）+100）= 429,496,729,700

此方法应从EEPROM或FLASH存储器中获得最长寿命，对于FLASH存储器，base-1编号应反转存储，因为擦除状态为逻辑1。

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

给我发电子邮件，我可以给你这个程序，它可以在MVS 2013控制台中使用。

lion@palmbeach.freeserve.co.uk

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

/ *此程序旨在测试eeprom生命，写入同一页面和单元格* /

/ * 32位base-2二进制数+ 100位base-1二进制数使得数字为* /

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

/ * byte 1 - * /

/ * byte 2 - * /

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

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

/ * byte 5 - 计算二进制base-1数字的0到8 * /

/ * byte 6 - 计算二进制base-1数字的9到16 * /

/ * byte 7 - 计算...... * /

的17到24

/ * byte 8 - 计数25到32 * /

/ * byte 9 - 计数33到40 * /

/ * byte 10 - 计数41到48 * /

/ * byte 11 - 计数49到56 * /

/ * byte 12 - 计数57到64 * /

/ * byte 13 - 计数65到72 * /

/ * byte 14 - 计数73到80 * /

/ * byte 15 - 计数81到88 * /

/ * byte 16 - 计数89到96 * /

/ * byte 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++;
}

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

1 个答案: